【并发基础】线程池实现原理分析

什么是线程池

• 线程池就是系统为了方便管理线程而事先创建一些缓冲线程，它们的集合称为线程池

使用线程池的好处

• 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
• 第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
• 第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源

ThreadPoolExecutor

Executors

Executors工具类提供了几个静态方法供我们创建线程池，但是都不被阿里规约推荐使用，下面分析其原因

• newCachedThreadPool
  创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
  线程池参数中最大线程数为最大整数值，可能发生OOM
• newFixedThreadPool
  创建一个固定大小线程池, 其中阻塞队列为最大整数值，可能发生OOM
• newScheduledThreadPool
  创建一个支持周期性调度的线程池, 其中最大线程数为最大整数值，可能发生OOM
• newSingleThreadExecutor
  创建一个单线程化的线程池, 其中阻塞队列为最大整数值，可能发生OOM

核心参数解释

• corePoolSize： 核心线程数即核心池的大小。 当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中
• maximumPoolSize： 线程池最大线程数，它表示在线程池中最多能创建多少个线程；超过最大线程数时将采用拒绝策略
• keepAliveTime： 表示线程没有任务执行时最多保持多久时间会终止。
  unit： 参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

工作流程

提交一个任务到线程池中，线程池的处理流程如下：

1、判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程2。
2、线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程3。
3、判断线程池里的线程是否大于最大线程数，如果不大于，则创建线程进入等待队列。如果已经阻塞队列也满了，则交给饱和策略来处理这个任务。

自定义线程线程池

注意事项

• 如果当前线程池中的线程数目**<corePoolSize**，则每来一个任务，就会创建一个线程去执行这个任务；
• 如果当前线程池中的线程数目**>=corePoolSize**，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程去执行这个任务；
• 如果缓存队列已经满了，则在总线程数不大于maximumPoolSize的前提下，则创建新的线程
• 如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理；
• 如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；
• 如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。

使用ThreadPoolExecutor创建线程池例子

public class Test0007 {

	public static void main(String[] args) {
		ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 2, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3));
		for (int i = 1; i <= 6; i++) {
			TaskThred t1 = new TaskThred("任务" + i);
			executor.execute(t1);
		}
		executor.shutdown();
	}
}

class TaskThred implements Runnable {
	private String taskName;

	public TaskThred(String taskName) {
		this.taskName = taskName;
	}

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+taskName);
	}

}

如何合理配置线程池

CPU密集型

CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。
CPU密集任务只有在真正的多核CPU上才可能得到加速(通过多线程)，而在单核CPU上，无论你开几个模拟的多线程，该任务都不可能得到加速，因为CPU总的运算能力就那些。

IO密集

IO密集型，即该任务需要大量的IO，即大量的阻塞。在单线程上运行IO密集型的任务会导致浪费大量的CPU运算能力浪费在等待。所以在IO密集型任务中使用多线程可以大大的加速程序运行，即时在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。

分析角度

1. 任务的性质：CPU密集型任务、IO密集型任务、混合型任务。
2. 任务的优先级：高、中、低。
3. 任务的执行时间：长、中、短。
4. 任务的依赖性：是否依赖其他系统资源，如数据库连接等。

最佳实践

• CPU密集型时，任务可以少配置线程数，大概和机器的cpu核数相当，这样可以使得每个线程都在执行任务

• IO密集型时，大部分线程都阻塞，故需要多配置线程数，2*cpu核数

一个基于线程池技术的简单Web服务器

	public class SimpleHttpServer {
		// 处理HttpRequest的线程池 
		static ThreadPool < HttpRequestHandler > threadPool = new DefaultThreadPool < HttpRequestHandler > (1);
		// SimpleHttpServer的根路径
		static String basePath;
		static ServerSocket serverSocket;
		// 服务监听端口 
		static int port = 8080;
		public static void setPort(int port) {
			if (port > 0) {
				SimpleHttpServer.port = port;
			}
		}
		public static void setBasePath(String basePath) {
			if (basePath != null && new File(basePath).exists() && new File(basePath).isDirectory()) {
				SimpleHttpServer.basePath = basePath;
			}
		}
		// 启动SimpleHttpServer public static void start() throws Exception { serverSocket = new ServerSocket(port);
		Socket socket = null;
		while ((socket = serverSocket.accept()) != null) {
			// 接收一个客户端Socket，生成一个HttpRequestHandler，放入线程池执行 
			threadPool.execute(new HttpRequestHandler(socket));
		}
		serverSocket.close();
	}
	static class HttpRequestHandler implements Runnable {
		private Socket socket;
		public HttpRequestHandler(Socket socket) {
			this.socket = socket;
		}
		@Override public void run() {
			String line = null;
			BufferedReader br = null;
			BufferedReader reader = null;
			PrintWriter out = null;
			InputStream in = null;
			try {
				reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
				String header = reader.readLine();
				// 由相对路径计算出绝对路径 
				String filePath = basePath + header.split(" ")[1];
				out = new PrintWriter(socket.getOutputStream());
				// 如果请求资源的后缀为jpg或者ico，则读取资源并输出 
				if (filePath.endsWith("jpg") || filePath.endsWith("ico")) {
					in = new FileInputStream(filePath);
					ByteArrayOutputStream baos = new ByteArrayOutputStream();
					int i = 0;
					while ((i = in.read()) != -1) {
						baos.write(i);
					}
					byte[] array = baos.toByteArray();
					out.println("HTTP/1.1 200 OK");
					out.println("Server: Molly");
					out.println("Content-Type: image/jpeg");
					out.println("Content-Length: " + array.length);
					out.println("");
					socket.getOutputStream().write(array, 0, array.length);
				} else {
					br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath)));
					out = new PrintWriter(socket.getOutputStream());
					out.println("HTTP/1.1 200 OK");
					out.println("Server: Molly");
					out.println("Content-Type: text/html; charset=UTF-8");
					out.println("");
					while ((line = br.readLine()) != null) {
						out.println(line);
					}
				}
				out.flush();
			}
			catch (Exception ex) {
				out.println("HTTP/1.1 500");
				out.println("");
				out.flush();
			}
			finally {
				close(br, in , reader, out, socket);
			}
		}
	}
	// 关闭流或者Socket 
	private static void close(Closeable... closeables) {
		if (closeables != null) {
			for (Closeable closeable : closeables) {
				try {
					closeable.close();
				}
				catch (Exception ex) {
				}
			}
		}
	}
}

对以上代码进行QPS测试发现随着线程池中线程数量的增加，SimpleHttpServer的吞吐量不断增大，响应时间 不断变小，线程池的作用非常明显。 但是，线程池中线程数量并不是越多越好，具体的数量需要评估每个任务的处理时间，以 及当前计算机的处理器能力和数量。使用的线程过少，无法发挥处理器的性能；使用的线程过 多，将会增加系统的无故开销，起到相反的作用。