java多线程之线程池

1).线程池简介    

    假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。
    如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。
                一个线程池包括以下四个基本组成部分：
                1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；
                2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；
                3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
                4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。
                
    线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。
    线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一个例子：
    假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。     

合理运用线程池，可以带来几点好处，降低资源消耗，提高响应速度，提高线程的可管理性，防止服务过载。

2).Executors线程池工具类

     我们可以通过 Executors.new......来创建线程池，比如 Executors.newCachedThreadPool()来创建一个缓存线程池,查看Executors源码可以发现有5种不同的线程池，我们依次来看一下

 I.线程池中包含指定个数的线程(定长线程池)

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
    }

II.创建一个单线程的线程池

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));
    }

III.创建一个可缓存的线程池

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());
    }

其中有三个线程池是通过ThreadPoolExecutor()创建的，所以我们有必要看下ThreadPoolExecutor这个类

ThreadPoolExecutor类

ThreadPoolExecutor有四个构造方法，前面三个构造都是调用最后一个构造实现的，所以我们看下最后一个构造方法

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

依次介绍下各个参数的意思，

corePoolSize 是核心线程个数

maximumPoolSize 线程池最大线程个数，核心线程个数<=线程池最大个数

keepAliveTime 是线程空闲时存活时间，就是说线程没事做的时候，过多久会被销毁

unit 是线程存活时间的单位

workQueue 是阻塞队列

threadFactory 是线程工厂，也就是线程池生产线程的工厂类

handler 是当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略还处理新提交的任务，handler有四种可以选择的参数，当然也可以自己实现RejectedExecutionHandler来自定义饱和策略

AbortPolicy:直接抛出异常，默认情况下采用这种策略
CallerRunsPolicy:只用调用者所在线程来运行任务
DiscardOldestPolicy:丢弃队列里最近的一个任务，并执行当前任务

DiscardPolicy:不处理，丢弃掉

下面看一个自定义线程池的例子

package com.zuokai.thread0427;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.DiscardPolicy;
import java.util.concurrent.TimeUnit;

/**
 * 自定义线程池
 * @author lijh
 *
 */
public class MyThreadPool{
	
	public static ExecutorService newMyThreadPool(int corePoolSize,int maximumPoolSize,int keepAliveTime){
		//corePoolSize 核心线程数量  maximumPoolSize 线程最大数量  keepAliveTime 线程空闲时，保持存活时间  unit 保持存活时间的单位  workQueue 队列
		//用给定的初始参数和默认的线程工厂及被拒绝的执行处理程序创建新的 ThreadPoolExecutor。
		//ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)
		
		//handler 饱和策略
		//用给定的初始参数和默认的线程工厂创建新的 ThreadPoolExecutor。
		//ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)
		
		//threadFactory 线程工厂
		//用给定的初始参数和默认被拒绝的执行处理程序创建新的 ThreadPoolExecutor
		//ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory)
		
		//用给定的初始参数创建新的 ThreadPoolExecutor
		//ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) 
		
		
		//handler 当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略还处理新提交的任务
		//AbortPolicy:直接抛出异常，默认情况下采用这种策略
		//CallerRunsPolicy:只用调用者所在线程来运行任务
		//DiscardOldestPolicy:丢弃队列里最近的一个任务，并执行当前任务
		//DiscardPolicy:不处理，丢弃掉
		
		
		//workQueue 用于保存等待执行的任务的阻塞队列
		//ArrayBlockingQueue:是一个基于数组结构的有界阻塞队列，按FIFO原则进行排序
		//LinkedBlockingQueue:一个基于链表结构的阻塞队列，吞吐量高于ArrayBlockingQueue。静态工厂方法Excutors.newFixedThreadPool()使用了这个队列
		//SynchronousQueue: 一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，
		//吞吐量高于LinkedBlockingQueue，静态工厂方法Excutors.newCachedThreadPool()使用了这个队列
		//PriorityBlockingQueue:一个具有优先级的无限阻塞队列。
		
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5),new MyRejectedExecutionHandler());
		return threadPoolExecutor;
		
	}
	
}

class MyRejectedExecutionHandler implements RejectedExecutionHandler{

	@Override
	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
		DiscardPolicy dp = new DiscardPolicy();
		executor.setRejectedExecutionHandler(dp);
		System.out.println("线程池和任务队列已经饱和，此线程被抛弃");
	}
	
}

IV.创建一个线程池，它可以安排在给定的延迟之后运行的命令，或者定期执行

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

ScheduledThreadPoolExecutor调用了父类的方法

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

最后还是使用了ThreadPoolExecutor来创建线程池，队列是使用延时队列

V.创建一个带并行级别的线程池，并行级别决定了同一时刻最多有多少个线程在执行，如不传入并行级别参数，将默认为当前系统的CPU个数。

public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }