0308线程池

线程池：三大方法、7大参数、4种拒绝策略

线程池的好处:
1、降低资源的消耗
2、提高响应的速度
3、方便管理。
线程复用、可以控制最大并发数、管理线程

三大方法

ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一个固定的线程池的大小
ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩的，遇强则强，遇弱则弱

例子：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// Executors 工具类、3大方法
public class Demo01 {
		public static void main(String[] args) {
			ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
			// ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一个固定的线程池的大小
			// ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩的，遇强则强，遇弱则弱
			try {
				for (int i = 0; i < 100; i++) {
					// 使用了线程池之后，使用线程池来创建线程
					threadPool.execute(()->{
						System.out.println(Thread.currentThread().getName()+" ok");
				});
			}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				// 线程池用完，程序结束，关闭线程池
				threadPool.shutdown();
		}
	}
}

ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一个固定的线程池的大小
ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩的，遇强则强，遇弱则弱

7大参数

源码：

public static ExecutorService newSingleThreadExecutor() {
	return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));
	//核心线程数：1
	//最大线程池大小：1
	//超时0释放
	//单位：MILLISECONDS
	//阻塞队列LinkedBlockingQueue
}
public static ExecutorService newFixedThreadPool(int nThreads) {
	return new ThreadPoolExecutor(5, 5,	0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newCachedThreadPool() {
	return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());
}

本质是调用ThreadPoolExecutor

ThreadPoolExecutor源码：

public ThreadPoolExecutor(int corePoolSize, // 核心线程池大小
	int maximumPoolSize, // 最大核心线程池大小
	long keepAliveTime, //同步时间。 超时了没有人调用就会释放
	TimeUnit unit, // 超时单位
	BlockingQueue<Runnable> workQueue, // 阻塞队列
	ThreadFactory threadFactory, // 线程工厂：创建线程的，一般不用动
	RejectedExecutionHandler handle)// 拒绝策略
	{
		if (corePoolSize < 0 ||	maximumPoolSize <= 0 ||	maximumPoolSize < corePoolSize ||	keepAliveTime < 0)
			throw new IllegalArgumentException();
		if (workQueue == null || threadFactory == null || handler == null)
			throw new NullPointerException();
		this.acc = System.getSecurityManager() == null ?null :	AccessController.getContext();
		this.corePoolSize = corePoolSize;
		this.maximumPoolSize = maximumPoolSize;
		this.workQueue = workQueue;
		this.keepAliveTime = unit.toNanos(keepAliveTime);
		this.threadFactory = threadFactory;
		this.handler = handler;
}

4种拒绝策略

/**
* new ThreadPoolExecutor.AbortPolicy() // 银行满了，还有人进来，不处理这个人的，抛出异
常
* new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里！
* new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！
* new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的竞争，也不会
抛出异常！
*/

例子：

import java.util.concurrent.*;
public class Demo01 {
	public static void main(String[] args) {
		// 自定义线程池！工作 ThreadPoolExecutor
		// 最大线程到底该如何定义
		// 1、CPU 密集型，几核，就是几，可以保持CPu的效率最高！
		// 2、IO 密集型 > 判断你程序中十分耗IO的线程，
		// 程序 15个大型任务 io十分占用资源！
		// 获取CPU的核数
		System.out.println(Runtime.getRuntime().availableProcessors());
		ExecutorService threadPool = new ThreadPoolExecutor(
			2,
			Runtime.getRuntime().availableProcessors(),
			3,
			TimeUnit.SECONDS,
			new LinkedBlockingDeque<>(3),
			Executors.defaultThreadFactory(),
			new ThreadPoolExecutor.DiscardOldestPolicy()); 
			//队列满了，尝试去和最早的竞争，也不会抛出异常！
		try {
		// 最大承载：Deque + max
		// 超过 RejectedExecutionException
			for (int i = 1; i <= 9; i++) {
				// 使用了线程池之后，使用线程池来创建线程
				threadPool.execute(()->{
				System.out.println(Thread.currentThread().getName()+" ok");
				});
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 线程池用完，程序结束，关闭线程池
			threadPool.shutdown();
		}
	}
}