java多线程（二）线程池

java线程池

线程池应用场景：

如何创建线程池：

有什么区别：

不同线程池对应的应用场景

案例

输出结果

java线程池

Java线程池是一种预先创建一定数量的线程，并将任务提交给这些线程执行的机制。线程池可以避免频繁创建和销毁线程，提高程序的性能和响应速度。

为什么要创建线程池：

降低资源消耗：通过重复利用已创建的线程，避免线程的频繁创建和销毁，降低资源消耗。
提高响应速度：当任务到达时，任务不需要等待线程创建就能立即执行。
提高线程的可管理性：线程池可以进行统一的分配、调优和监控，有利于提高线程的可管理性。

线程池应用场景：

快速响应用户请求（IO密集型任务）：如用户要查看商品信息，需要将商品维度的一系列信息聚合起来展示给用户。通过使用线程池，可以快速响应用户请求。
快速处理批量任务（CPU密集型任务）：如统计某个报表，需要计算出全国各个门店中有哪些商品有某种属性，用于后续营销策略的分析。通过使用线程池，可以快速处理批量任务。

如何创建线程池：

Java中的线程池可以通过以下几种方式创建：

Executors.newFixedThreadPool：创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待。方法只有一个参数，即线程池的大小。
Executors.newCachedThreadPool：创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程。
Executors.newSingleThreadExecutor：创建一个单个线程数的线程池，它可以保证先进先出的执行顺序。
Executors.newScheduledThreadPool：创建一个可以执行延迟任务的线程池。
ThreadPoolExecutor：通过ThreadPoolExecutor类创建线程池，可以自定义线程池的参数，如核心线程数、最大线程数、队列类型等。

有什么区别：

使用 Executors 工厂类中的 newCachedThreadPool() 和 newFixedThreadPool() 方法：

优点：

- 使用起来比较简单，不需要自己手动管理线程池的状态；
- 可以快速创建线程池。

缺点：

- 无法自定义线程池的大小和饱和策略；
- 不够灵活。

使用 Executors 工厂类中的 newSingleThreadExecutor() 方法：

优点：

- 创建单个线程的线程池；
- 适用于需要顺序执行任务的场景。

缺点：

- 无法自定义线程池的大小和饱和策略；
- 不够灵活。

使用 ThreadPoolExecutor 类来创建线程池：

参数：

- corePoolSize：核心线程数
- maximumPoolSize：最大线程数
- keepAliveTime：线程存活时间
- unit：时间单位
- workQueue：任务队列
- threadFactory：线程工厂
- handler：饱和策略

优点：

- 可以根据实际情况来自定义线程池的大小、任务队列等；
- 可以灵活地设置饱和策略。

缺点：

- 对于不熟悉线程池的开发人员来说，使用起来比较麻烦；
- 需要手动管理线程池的状态。

核心线程数：指线程池中保持活动的最小线程数。如果线程池中的当前线程数小于核心线程数，则会在需要时创建新的线程。
最大线程数：指线程池中允许的最大线程数。如果队列满了，并且当前线程数已经达到最大线程数，则会在需要时创建新的线程。
队列类型：指用于存储待执行任务的队列类型。常见的队列类型有直接提交队列、有界队列、无界队列等。
拒绝策略：指当任务队列已满，且所有线程都在工作，但仍然无法处理新任务时的处理策略。常见的拒绝策略有抛出异常、拒绝任务、阻塞任务等。

以上几种方式分别对应不同的应用场景和需求。其中，Executors类提供了一种简单的方式来创建线程池，但它的参数相对固定，不适合进行复杂的配置。而ThreadPoolExecutor类则提供了更多的参数选项，可以灵活地配置线程池的各种属性，适用于更为复杂的场景。

不同线程池对应的应用场景

Executors.newFixedThreadPool：适用于需要控制并发线程数量的场景，例如，当需要确保每个请求都能得到响应时，或者当请求量很大时，可以控制并发线程数量，避免系统过载。-------需要创建固定数量的线程来执行长时间运行的任务；
Executors.newCachedThreadPool：适用于执行大量短期异步任务，例如，Web请求处理或短期的后台任务。这种线程池能快速创建和销毁线程，以应对大量突发任务。大量短时间的任务，如网络请求
Executors.newSingleThreadExecutor：适用于需要保证任务按照提交顺序执行的场景，例如，当需要保证任务的串行执行时。需要顺序执行任务的场景，如一个线程代表一个用户请求
Executors.newScheduledThreadPool：适用于需要定时或周期性执行任务的场景，例如，定时任务、定时备份等。
ThreadPoolExecutor：适用于需要自定义线程池参数的场景，例如，需要根据任务的特性（如优先级、执行时间等）来调整线程池的配置。这种线程池提供了更多的灵活性和控制性。复杂的应用场景，需要根据实际情况来动态地调整线程池的大小和饱和策略，如一个 Web 服务器上服务对多个用户的请求时

案例

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;/*** 线程处理类*/
public class ExecutorProcessPool {private ExecutorService executor;private static ExecutorProcessPool pool = new ExecutorProcessPool();private final int threadMax = 10;private ExecutorProcessPool() {System.out.println("threadMax>>>>>>>" + threadMax);executor = ExecutorServiceFactory.getInstance().createFixedThreadPool(threadMax);}public static ExecutorProcessPool getInstance() {return pool;}/*** 关闭线程池，这里要说明的是：调用关闭线程池方法后，线程池会执行完队列中的所有任务才退出*/public void shutdown() {executor.shutdown();}/*** 提交任务到线程池，可以接收线程返回值** @param task* @return*/public Future<?> submit(Runnable task) {return executor.submit(task);}/*** 提交任务到线程池，可以接收线程返回值** @param task* @return*/public Future<?> submit(Callable<?> task) {return executor.submit(task);}/*** 直接提交任务到线程池，无返回值** @param task*/public void execute(Runnable task) {executor.execute(task);}}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;/*** 线程池构造工厂*/
public class ExecutorServiceFactory {private static ExecutorServiceFactory executorFactory = new ExecutorServiceFactory();/*** 定时任务线程池*/private ExecutorService executors;private ExecutorServiceFactory() {}/*** 获取ExecutorServiceFactory** @return*/public static ExecutorServiceFactory getInstance() {return executorFactory;}/*** 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。** @return*/public ExecutorService createScheduledThreadPool() {// CPU个数int availableProcessors = Runtime.getRuntime().availableProcessors();// 创建executors = Executors.newScheduledThreadPool(availableProcessors * 10, getThreadFactory());return executors;}/*** 创建一个使用单个 worker 线程的* Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，* 那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的* newFixedThreadPool(1) 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。** @return*/public ExecutorService createSingleThreadExecutor() {// 创建executors = Executors.newSingleThreadExecutor(getThreadFactory());return executors;}/*** 创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用* execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60* 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。注意，可以使用 ThreadPoolExecutor* 构造方法创建具有类似属性但细节不同（例如超时参数）的线程池。** @return*/public ExecutorService createCachedThreadPool() {// 创建executors = Executors.newCachedThreadPool(getThreadFactory());return executors;}/*** 创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads* 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务* ，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止* ，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。** @return*/public ExecutorService createFixedThreadPool(int count) {// 创建executors = Executors.newFixedThreadPool(count, getThreadFactory());return executors;}/*** 获取线程池工厂** @return*/private ThreadFactory getThreadFactory() {return new ThreadFactory() {AtomicInteger sn = new AtomicInteger();public Thread newThread(Runnable r) {SecurityManager s = System.getSecurityManager();ThreadGroup group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();Thread t = new Thread(group, r);t.setName("任务线程 - " + sn.incrementAndGet());return t;}};}
}


import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;/*** 测试类*/
public class ExecutorTest {public static void main(String[] args) {ExecutorProcessPool pool = ExecutorProcessPool.getInstance();/* for (int i = 0; i < 200; i++) {Future<?> future = pool.submit(new ExcuteTask1(i+""));
//          try {
//              如果接收线程返回值，future.get() 会阻塞，如果这样写就是一个线程一个线程执行。所以非特殊情况不建议使用接收返回值的。
//              System.out.println(future.get());
//          } catch (Exception e) {
//              e.printStackTrace();
//          }}*/List<String> list = new ArrayList(Arrays.asList("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "n", "m", "o", "p"));for (int i = 0; i < list.size(); i++) {String s = list.get(i);pool.execute(new ExcuteTask2(s + ""));}//关闭线程池，如果是需要长期运行的线程池，不用调用该方法。//监听程序退出的时候最好执行一下。List<String> list2 = new ArrayList(Arrays.asList("的", "飞", "个", "个", "3"));for (int i = 0; i < list2.size(); i++) {String s = list2.get(i);pool.execute(new ExcuteTask2(s + ""));}
//        pool.shutdown();}/*** 执行任务1，实现Callable方式*/static class ExcuteTask1 implements Callable<String> {private String taskName;public ExcuteTask1(String taskName) {this.taskName = taskName;}@Overridepublic String call() throws Exception {try {
//              Java 6/7最佳的休眠方法为TimeUnit.MILLISECONDS.sleep(100);
//              最好不要用 Thread.sleep(100);TimeUnit.MILLISECONDS.sleep((int) (Math.random() * 1000));// 1000毫秒以内的随机数，模拟业务逻辑处理} catch (Exception e) {e.printStackTrace();}System.out.println("-------------这里执行业务逻辑，Callable TaskName = " + taskName + "-------------");return ">>>>>>>>>>>>>线程返回值，Callable TaskName = " + taskName + "<<<<<<<<<<<<<<";}}/*** 执行任务2，实现Runable方式*/static class ExcuteTask2 implements Runnable {private String taskName;public ExcuteTask2(String taskName) {this.taskName = taskName;}@Overridepublic void run() {try {TimeUnit.MILLISECONDS.sleep((int) (Math.random() * 1000));// 1000毫秒以内的随机数，模拟业务逻辑处理} catch (Exception e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "-------------这里执行业务逻辑，Runnable TaskName = " + taskName + "-------------");}}
}