多线程学习-线程池分析

简介

提供了一个线程队列，队列中保存着所有等待状态的线程，避免了创建和销毁的额外开销，提高了响应速度。

线程池可以解决两个不同问题：由于减少了每个任务调用的开销，它们通常可以在执行大量异步任务时提供增强的性能，并且还可以提供绑定和管理资源（包括执行任务集时使用的线程）的方法。每个 ThreadPoolExecutor 还维护着一些基本的统计数据，如完成的任务数。

为了避免重复的创建线程，线程池的出现可以让线程进行复用。通俗点讲，当有工作来，就会向线程池拿一个线程，当工作完成后，并不是直接关闭线程，而是将这个线程归还给线程池供其他任务使用。

参考： https://www.cnblogs.com/superfj/p/7544971.html

线程池的结构

参考：https://cloud.tencent.com/developer/article/1124439

• java.util.concurrent.Executor： 负责线程的使用与调度的根接口
• ExecutorService 子接口：线程池的主要接口
• ThreadPoolExecutor： 实现类
• ScheduledExecutorService：子接口：负责线程的调度
• ScheduledThreadPoolExecutor：实现类：继承了ThreadPoolExecutor，实现了ScheduledExecutorService接口，具备线程池和线程调度功能

线程池具体实现

参考：https://blog.csdn.net/wysnxzm/article/details/81709687

newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。可能导致内存溢出,一般使用newFixedThreadPool代替

newFixedThreadPool

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

package com.juc;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建和销毁线程的开销
 * newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
 */
public class TestThreadPool {

	public static void main(String[] args) {

		ThreadPoolDemo threadPoolDemo = new ThreadPoolDemo();

		// 1.创建线程池
		ExecutorService pool = Executors.newFixedThreadPool(5);
		// 2.为线程池中的线程分配任务
		List<Future<Integer>> futureList = Lists.newArrayList();
		for (int i = 0; i < 10; i++) {
			Future<Integer> future = pool.submit(new Callable<Integer>() {
				@Override
				public Integer call() throws Exception {
					int sum = 0;
					for (int j = 0; j <= 100; j++) {
						sum += j;
					}
					return sum;
				}
			});
			futureList.add(future);
		}
		// 3.关闭线程池
		pool.shutdown();
		futureList.forEach(x -> {
			try {
				System.out.println(x.get());
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				e.printStackTrace();
			}

		});

		// // 1.创建线程池
		// ExecutorService pool = Executors.newFixedThreadPool(5);
		// // 2.为线程池中的线程分配任务
		// for (int i = 0; i < 10; i++) {
		// pool.submit(threadPoolDemo);
		// }
		// // 3.关闭线程池
		// pool.shutdown();
	}
}

/**
 * 多线程
 */
class ThreadPoolDemo implements Runnable {
	private int index = 0;
	@Override
	public void run() {
		while (index <= 100) {
			System.out.println(Thread.currentThread().getName() + "-->" + index++);
		}
	}
}

newScheduledThreadPool

创建一个定长线程池，支持定时及周期性任务执行

package com.juc;
import java.time.LocalDateTime;
import java.util.Random;
import java.util.concurrent.*;

/**
 * 线程池调度
 */
public class TestScheduledThreadPool {

	public static void main(String[] args) throws ExecutionException, InterruptedException {

		ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
		for (int i = 0; i < 10; i++) {
			Future<Integer> future = pool.schedule(new Callable<Integer>() {
				@Override
				public Integer call() {
					int number = new Random().nextInt(100);// 生成随机数
					System.out.println(Thread.currentThread().getName() + " : "
							+ LocalDateTime.now() + "--->" + number);
					return number;
				}
			}, 3, TimeUnit.SECONDS); // 定时每隔三秒执行一次，线程调度

			System.out.println(future.get());
		}
		pool.shutdown();
	}
}

newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

newSingleThreadScheduledExecutor

创建只有一条线程的线程池，他可以在指定延迟后执行线程任务

newWorkStealingPool

会更加所需的并行层次来动态创建和关闭线程。它同样会试图减少任务队列的大小，所以比较适于高负载的环境。同样也比较适用于当执行的任务会创建更多任务，如递归任务。