JAVA：线程池的应用示例

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

public class Test {

	public static void main(String[] args) {
		// 获取当前电脑可用cpu数*2=可用线程数
		int poolSize = Runtime.getRuntime().availableProcessors() * 2;
		/*
		 * 设置队列最大长度，可选择的类为：
		 * ArrayBlockingQueue;
		 * LinkedBlockingQueue;
		 * SynchronousQueue;
		 * ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。
		 * 线程池的排队策略与BlockingQueue有关。
		 */
		BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);
		/*
		 * 设置拒绝策略
		 * AbortPolicy	丢弃任务并抛出RejectedExecutionException异常
		 * DiscardPolicy	丢弃任务，但是不抛出异常
		 * DiscardOldestPolicy	丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
		 * CallerRunsPolicy	由调用线程处理该任务 
		 */
		RejectedExecutionHandler policy = new ThreadPoolExecutor.CallerRunsPolicy();
		/*
		 * 设置keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：
		 * TimeUnit.DAYS;               //天
		 * TimeUnit.HOURS;             //小时
		 * TimeUnit.MINUTES;           //分钟
		 * TimeUnit.SECONDS;           //秒
		 * TimeUnit.MILLISECONDS;      //毫秒
		 * TimeUnit.MICROSECONDS;      //微妙
		 * TimeUnit.NANOSECONDS;       //纳秒
		 */
		TimeUnit unit = TimeUnit.SECONDS;
		/*
		 *创建es线程池
		 *参数1：int corePoolSize, // 线程池长期维持的线程数，即使线程处于Idle状态，也不会回收。
		 *参数2：int maximumPoolSize, // 线程数的上限
		 *参数3：long keepAliveTime, // 超过corePoolSize的线程的idle时长，超过这个时间，多余的线程会被回收。
		 *参数4：TimeUnit unit,// keepAliveTime的时间单位
		 *参数5：BlockingQueue<Runnable> workQueue, // 任务的排队队列
		 *参数6：ThreadFactory threadFactory, // 新线程的产生方式
		 *参数7：RejectedExecutionHandler handler) // 拒绝策略
		 */
		ExecutorService es = new ThreadPoolExecutor(poolSize, poolSize, 0, unit, queue, policy);
		/*
		 * 向线程池提交任务方法：
		 * execute(Runnable x) 没有返回值。可以执行任务，但无法判断任务是否成功完成。——实现Runnable接口
		 * submit(Callable x) 返回一个future。可以用这个future来判断任务是否成功完成。——实现Callable接口
		 * shutdown() 关闭线程池：按过去执行已提交任务的顺序发起一个有序的关闭，但是不接受新任务
		 * shutdownNow() 关闭线程池：尝试停止所有的活动执行任务、暂停等待任务的处理，并返回等待执行的任务列表
		 */
		for (int j = 0; j < 20; j++) {
			es.execute(new Runnable() {
				@Override
				public void run() {
					System.out.println("线程" + Thread.currentThread().getName());

				}
			});
		}
		es.shutdown();
	}
}

4核心cpu运行结果如下：
线程pool-1-thread-1
线程pool-1-thread-2
线程pool-1-thread-3
线程pool-1-thread-4
线程pool-1-thread-6
线程pool-1-thread-5
线程main
线程main
线程pool-1-thread-5
线程pool-1-thread-5
线程pool-1-thread-5
线程pool-1-thread-5
线程pool-1-thread-5
线程pool-1-thread-5
线程pool-1-thread-5
线程pool-1-thread-5
线程pool-1-thread-5
线程pool-1-thread-5
线程pool-1-thread-8
线程pool-1-thread-7

使用线程池工厂Executors创建线程池：
Executors.newCachedThreadPool(); //创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE
Executors.newSingleThreadExecutor();//创建容量为1的缓冲池
Executors.newFixedThreadPool(int);//创建固定容量大小的缓冲池
示例：

ExecutorService es = Executors.newFixedThreadPool(8);
Future<String> future = es.submit(new Callable<String>() {
	@Override
	public String call() throws Exception {
		// TODO Auto-generated method stub
		return "返回";
	}
});
es.shutdown();
try {
	System.out.println(future.get());
} catch (InterruptedException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} catch (ExecutionException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}