Java线程池

在线程的使用中，如果并发的数量很多，但是每个线程执行的时间又比较短，这会造成系统频繁的创建和销毁线程，大大的降低了系统的效率。

线程池的实现方式：

我们可以通过使用java中的ThreadPoolExecutor来创建线程池。

ThreadPoolExecutor继承了AbstractExecutorService，AbstractExecutorService实现了ExecutorService接口，ExecutorService继承了Executor接口。这些类的源码可以自己去了解。

ThreadPoolExecutor提供了四个构造函数：

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

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

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

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

前三个构造函数最终都是调用了最后一个构造函数。

各个参数的意义：

corePoolSize：核心池的大小，在创建线程池后，线程池中的线程数为0，当有任务来是，就会创建一个线程来执行任务，当线程池中的线程数目达到corePoolSize之后就会加到缓存队列中。当缓存队列中满时，会创建一个非核心线程。

maximumPoolSize：线程池最大线程数，表示在线程池中最多能创建多少线程。

keepAliveTime：表示线程在没有执行任务时最多会存活多久时间，默认情况下，只对非核心线程起作用，但是如果设置了allowCoreThreadTimeOut = true，当核心线程超过这个时间没被使用也会被销毁。

unit：参数keepAliveTime的时间单位，有7种。

NANOSECONDS ：1微毫秒

MICROSECONDS ：1微秒

MILLISECONDS ：1毫秒

SECONDS ：秒

MINUTES ：分

HOURS ：小时

DAYS ：天

workQueue：阻塞队列，用来存储等待执行的任务。有以下几种

SynchronousQueue：这个队列接收到任务的时候，会直接提交给线程处理，而不会将任务存入缓存对列，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大。

LinkedBlockingQueue：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建核心线程处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效。

ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建核心线程执行任务，如果达到了，则入队等候，如果队列已满，则新建非核心线程执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，执行reject操作。

DelayQueue：队列内元素必须实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务。

threadFactory：线程工厂，用来创建线程，默认为DefaultThreadFactory

handler：表示当拒绝处理任务时的策略，也就是reject操作，有以下几种：

ThreadPoolExecutor.AbortPolicy：丢弃任务并抛出RejectedExecutionException异常。（默认handle）。

ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。

ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）。

ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务。

一个使用线程池的例子：

package thread;

public class MyThread extends Thread {
	
	private int i = 0;
	private int num = 0;
	
	@Override
	public void run() {
		for(i = 1;i <= 10000;i++){
			num += i;
		}
		System.out.println(Thread.currentThread().getName() + "：" + num);
	}
}

package thread;

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

public class MyThreadPoolExecutor{
	public static void main(String[] args) {
		ThreadPoolExecutor executor = new ThreadPoolExecutor(10, Integer.MAX_VALUE, 200, 
				TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>());
//		ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 15, 200, 
//				TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
//		ThreadPoolExecutor executor = new ThreadPoolExecutor(10, Integer.MAX_VALUE, 200, 
//				TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(5));
		for(int i = 0;i < 100;i++){
			MyThread myThread = new MyThread();
			executor.execute(myThread);
			System.out.println("线程池中的线程数目："+executor.getPoolSize()
			+",队列中等待执行的任务数目："+executor.getQueue().size()+
			"已执行完的任务数："+executor.getCompletedTaskCount());
		}
		executor.shutdown();
		
	}
	
}

为了防止在使用ArrayBlockingQueue抛异常，所以在这个例子中将maximumPoolSize设置为Integer.MAX_VALUE，大家可以试一下改成其他数值，观察运行结果。

由于笔者知识水平有限，如果有写的不对或者不完善的地方欢迎大家指出，谢谢。