Java 线程池工作原理

Java 线程池工作原理


背景和目的：
1.假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。
如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。
2.如果每个任务到来都进行线程的创建，运行完成后再消毁线程，当任务请求非常多时，应用就有非常多的线程同时创建,
运行时就有非常多的线程进行切换，这种对系统资源的开销是非常大的。
3.除了创建和销毁线程的开销之外，活动的线程也消耗系统资源。在一个JVM 里创建太多的线程可能会导致系统由于过度
消耗内存而用完内存或“切换过度”。
4.线程池就是为了解决上述问题提出的解决方案。
5.Java中的ThreadPoolExecutor类是实现线程池的一个类。


线程池四个基本组成部分：
1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括创建线程池，销毁线程池，添加新任务；
2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务，工作线程是线程池进行创建和销毁的（无需人为创建）；
3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。（任务就是自己按业务需求进行编写的(实现implements Runnable接口run)实例对象）


线程池工作原理：
1.应用启动时就进行若干个工作线程的初始化，并存入线程池中。这样工作线程(ThreadPoolExecutor中Worker)就创建了。
2.任务到达时，将任放到任务队列(ThreadPoolExecutor中workQueue)中。(如：threadPoolExecutor.execute(myTask);)
3.工作线程从任务队列中取出任务并运行任务接口进行任务的处理。
4.当任务队列中的任务非常多时，线程池管理器就会创建新的工作线程(ThreadPoolExecutor中Worker)放入线程池中，新的工作线程也进行任务的处理。
5.这样做就减少了应用中线程的个数，运行任务时没有进行线程的创建；线程个数减少，线程切换的系统开销也就减少了。
6.就是将任务就成一个实例(实现implements Runnable接口run),并创建指定个线程(ThreadPoolExecutor中Worker)不断地从任务队列(ThreadPoolExecutor中workQueue)
中取出任务实例，并运行实例中的run方法。



Java中的ThreadPoolExecutor类

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);
    ...
}

1.corePoolSize：核心池的大小，(主工作线程的个数)
2.maximumPoolSize：线程池最大线程数（比corePoolSize大的都是临时的，需要的时候才创建放到线程池中）
3.keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。
4.unit：参数keepAliveTime的时间单位，

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

5.workQueue：一个阻塞队列，用来存储等待执行的任务，
6.threadFactory：线程工厂，主要用来创建线程；
7.handler：表示当拒绝处理任务时的策略，有以下四种取值：

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

ThreadPoolExecutor类中其他的一些比较重要成员变量

private final BlockingQueue<Runnable> workQueue;              //任务缓存队列，用来存放等待执行的任务
private final ReentrantLock mainLock = new ReentrantLock();   //线程池的主要状态锁，对线程池状态（比如线程池大小
                                                              //、runState等）的改变都要使用这个锁
private final HashSet<Worker> workers = new HashSet<Worker>();  //用来存放工作集

private volatile long  keepAliveTime;    //线程存货时间
private volatile boolean allowCoreThreadTimeOut;   //是否允许为核心线程设置存活时间
private volatile int   corePoolSize;     //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）
private volatile int   maximumPoolSize;   //线程池最大能容忍的线程数

private volatile int   poolSize;       //线程池中当前的线程数

private volatile RejectedExecutionHandler handler; //任务拒绝策略

private volatile ThreadFactory threadFactory;   //线程工厂，用来创建线程

private int largestPoolSize;   //用来记录线程池中曾经出现过的最大线程数

private long completedTaskCount;   //用来记录已经执行完毕的任务个数

任务的提交

execute()	//这个方法可以向线程池提交一个任务，交由线程池去执行。
submit()	//这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果
shutdown()	//线程池处于SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕
shutdownNow()	//线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务

例子：

package ThreadPool;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPool {
	public static void main(String[] args) {
		ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10, 200, TimeUnit.MILLISECONDS,
				new LinkedBlockingQueue(100));

		for (int j = 0; j < 16; j++) {
			for (int i = 0; i < 16; i++) {
				MyTask myTask = new MyTask(j*100+i);
				threadPoolExecutor.execute(myTask);
				System.out.println("线程池中线程数目：" + threadPoolExecutor.getPoolSize() + "，队列中等待执行的任务数目：" + threadPoolExecutor.getQueue().size()
						+ "，已执行完的任务数目：" + threadPoolExecutor.getCompletedTaskCount());
			}
		}
		threadPoolExecutor.shutdown();
	}
}

package ThreadPool;

class MyTask implements Runnable { //实现接口Runnable接口run,
	private int taskNum;

	public MyTask(int num) {
		this.taskNum = num;
	}

	public void run() {//接口run，你的任务逻辑在这里实现
		System.out.println("正在执行task " + this.taskNum);
		System.out.println("task " + taskNum + "执行完毕");
	}
}

spring线程池(TaskExecutor)
参考原文：http://lishaorui.iteye.com/blog/1051823


参考原文：http://www.cnblogs.com/dolphin0520/p/3932921.html
参考原文：http://www.blogjava.net/stevenjohn/archive/2011/12/12/366161.html
参考原文：http://wenku.baidu.com/link?url=GoqD2-ouxAVhPVfs20rqelSjDPs8IPHq6dQanWuJpca8Em9yxiGMLoHS2-1Pyq8tec9Z25z8FiqDJBhWhKUSAd82YEW4Bu7wio7JTHUp3YG


https://www.cnblogs.com/zhaoyan001/p/7049627.html