10.线程池_线程调度

/*线程池*/

/*第四种 获取线程的方法：线程池*/

一个ExecutorService，它使用线程池的可能的某个线程之一执行每个提交的任务，通常使用 Executors 工厂方法配置（ExecutorService service = Executors.newFixedThreadPool(5);）

线程池可以解决两个不同问题：

　　1.由于减少了每个任务的开销，它们通常可以在执行大量异步任务时 提供增强的性能，

　　2.并且还可以提供绑定和管理资源（包括执行任务集时使用的线程）的方法。每个ThreadPoolExecutor 还维护着一些基本的统计数据，如完成的任务数。

为了便于跨大量上下文使用，此类提供了很多可调整的参数和扩展钩子（hook）.但是强烈建议 程序员使用较为方便的Executors 工厂方法

　　Executors.newCachedThreadPool() (无界线程池，可以进行自动线程回收)

　　Executors.newFixedThreadPool(int) (固定线程池大小)

　　Executors.newSingleThreadExecutors (单个后台线程)

它们均为 大多数 使用场景预定了一些默认设置（一般不用修改）。

一、线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度

二、线程体系结构：

　　一、线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度
*
*　　 二、线程体系结构：

* java.util.concurrent.Executor:负责线程的使用与调度的根接口

* |--**ExecutorService 子接口：线程池的主要接口

* |--ThreadPoolExecutor 线程池的实现类

* |--ScheduledExecutorSerice 子接口：负责线程的调度

* |--ScheduledThreadPoolExecutor ： 继承ThreadPoolExecutor，实现 ScheduledExecutorService
*
* 三、工具类：Executors

* ExecutorService newFixedThreadPool() : 创建固定大小的线程池

* ExecutorService newCachedThreadPool() : 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量

* ExecutorService newSingleThreadPool() : 创建单个线程池 。线程池中只有一个线程

*
* ScheduleExecutorService new ScheduledThreadPool() : 创建固定大小的线程池，可以延迟或定时执行任务

/*使用线程池的是三个步骤*/

　　1.创建 线程池 （根据要求可以创建不同的线程池）

　　2.放入任务 （将任务交给线程池中的线程去执行）

　　3.关闭线程池 （一般需平缓关闭（等正在执行任务的线程执行完毕后））

/*
 * 一、线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度
 * 
 * 二、线程体系结构：
 * java.util.concurrent.Executor:负责线程的使用与调度的根接口
 *         |--**ExecutorService 子接口：线程池的主要接口
 *             |--ThreadPoolExecutor  线程池的实现类
 *             |--ScheduledExecutorSerice 子接口：负责线程的调度
 *                 |--ScheduledThreadPoolExecutor ： 继承ThreadPoolExecutor，实现 ScheduledExecutorService    
 * 
 * 三、工具类：Executors
 * ExecutorService newFixedThreadPool()  :  创建固定大小的线程池
 * ExecutorService newCachedThreadPool()  :  缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量
 * ExecutorService newSingleThreadPool()  :  创建单个线程池  。线程池中只有一个线程
 * 
 * ScheduleExecutorService  new ScheduledThreadPool()  :  创建固定大小的线程池，可以延迟或定时执行任务
 * */
public class TestThreadPool {
    public static void main(String[] args) throws Exception {
        // 1.创建线程池
        ThreadPoolDemo tpd = new ThreadPoolDemo();
        ExecutorService service = Executors.newFixedThreadPool(5);

        // 2。为线程池中的线程分配任务（实现 Callable<E>接口的任务）
        List<Future<Integer>> results = new ArrayList<Future<Integer>>();
        //执行多次任务，多次任务的返回值 构成一个 List
        for(int i = 0;i < 10;i++) {
            //通过 submit 方法 将任务放入线程池，交给线程池中的线程去执行
            Future<Integer> result = service.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    int sum = 0;
                    for (int i = 0; i <= 10; i++) {
                        sum = sum+ i;
                    }
                    return sum;
                }
            });
            results.add(result);
        }
         
        
        //3.获取call 返回的 数据
        for(Future<Integer> result: results) {
            System.out.println(Thread.currentThread().getName() + "  :  "+ result.get());
        }
        
        //4.关闭线程池 （平缓的）（不关闭线程池，程序不会结束的）
        service.shutdown();
        

        // 2.为线程池中的线程分配任务 (为5个线程分配10个任务)
        /*
         * for(int i = 0;i < 10; i++) { service.submit(tpd); }
         * 
         * //3.关闭 线程池（平缓的） service.shutdown();
         */
    }
}

class ThreadPoolDemo implements Runnable {
    private int i = 100;

    @Override
    public void run() {
        while (i >= 0) {
            System.out
                    .println(Thread.currentThread().getName() + "  :  " + i--);
        }
    }
}

ScheduleExecutorService  new ScheduledThreadPool()  :  创建固定大小的线程池，可以延迟或定时执行任务

public class TestScheduledThreadPool {
    public static void main(String[] args) throws Exception {
        // 创建 调度线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);

        for (int i = 0; i < 10; i++) {
            // 放入任务
            ScheduledFuture<Integer> result = service.schedule(   //schedule()  多了 几个参数，可以指定 延迟等待的时间 及 单位
                    new Callable<Integer>() {
                        @Override
                        public Integer call() throws Exception {
                            int sum = 0;
                            for (int i = 0; i < 100; i++) {
                                sum = sum + i;
                            }
                            System.out.println(Thread.currentThread().getName() + "   :   " + sum);
                            return sum;
                        }
                    }, 3, TimeUnit.SECONDS);

            // 得到call 的结果
            System.out.println(result.get());
        }
        
        //关闭线程池
        service.shutdown();

    }
}