线程池的原理及使用

一. 线程池的优点
1：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

2：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

3：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，
还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用
线程池，必须对其实现原理了如指掌。

二. 线程池的实现
* ThreadPoolExecutor 是实现线程池非常核心的一个类
ThreadPoolExecutor ——>继承了 AbstractExecutorService ——实现了 ExecutorService ——>继承了 Executor接口
注：Executor是一个顶层接口，在它里面只声明了一个方法execute(Runnable)，返回值为void，参数为Runnable类型，从字面意思可以理解，就是用来执行传进去的任务的；
public interface Executor { void execute(Runnable command); }
* 在ThreadPoolExecutor类中有几个非常重要的方法：

execute()
submit()
shutdown()
shutdownNow()

1.submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法。
2.shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
3.shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务

public class ThreadPoolExecutor extends AbstractExecutorService {
    .....
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue);

    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);

    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);

    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
    ...
}

参数解释：
* corePoolSize：核心线程数量，没有达到次数量线程会不断创建新的线程，个人理解就是线程池中正常适合容纳的线程的数量。

maximumPoolSize：线程池最多可以容纳的线程数量，超过这个会触发饱和策略（RejectedExecutionHandler）
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。注意：默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。
TimeUnit：keepAliveTime的单位。
枚举类型：

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

BlockingQueue：阻塞队列这里大致写一下，详细请自己查询

ArrayBlockingQueue;  //数组类型  有界，必须规定队列大小
LinkedBlockingQueue; //链表类型，默认Integer.MAX_VALUE
SynchronousQueue;   //一个不存储元素的阻塞队列

三. 线程的具体使用
代码：

public class Task extends Thread{
    private int num;

    public Task(int num) {
        this.num = num;
    }

    @Override
    public void run() {
        System.out.println("正在执行任务：" + num);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        System.out.println("结束任务：" + num);
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
                10, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(5));
        for(int i=0;i<15;i++){
            Task myTask = new Task(i);
            executor.execute(myTask);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程池中线程数目："+executor.getPoolSize()+"，队列中等待执行的任务数目："+
                    executor.getQueue().size()+"，已执行完别的任务数目："+executor.getCompletedTaskCount());
        }
        executor.shutdown();
    }
}

通过对任务时间，线程的keepAliveTime的调整，观察线程池的状态。具体如下：

1.在线程的数量没有达到corePoolSize时，会不断创建新的线程处理任务。

2.达到corePoolSize时会有两种情况，如果keepAliveTime很小，有线程在这个时候是空闲的，就会利用空闲线程处理任务，否则就让任务进入阻塞队列。

3.阻塞队列满时，会接着创建线程处理任务，直到到达maximumPoolSize，触发饱和策略。

四. 饱和策略
RejectedExecutionHandler（饱和策略）：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

线程池的原理及使用

猜你喜欢