为什么要使用线程池？

池化思想：缓存手段，缓存昂贵的对象

  • 高效的执行任务。
  • 降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗
  • 提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行
  • 方便线程并发数的管控，减少CPU切换带来的性能损失
  • 提供更强大的功能，延时定时线程池

    如何使用线程池？

    ThreadPoolExecutor

    1. public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
    2.   this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
    3.        Executors.defaultThreadFactory(), defaultHandler);
    4. }
    1、corePoolSize（线程池基本大小）：当向线程池提交一个任务时，若线程池已创建的线程数小于corePoolSize，即便此时存在空闲线程，也会通过创建一个新线程来执行该任务，直到已创建的线程数大于或等于corePoolSize时，（除了利用提交新任务来创建和启动线程（按需构造），也可以通过 prestartCoreThread() 或 prestartAllCoreThreads() 方法来提前启动线程池中的基本线程。）
    2、maximumPoolSize（线程池最大大小）：线程池所允许的最大线程个数。当队列满了，且已创建的线程数小于maximumPoolSize，则线程池会创建新的线程来执行任务。另外，对于无界队列，可忽略该参数。
    3、keepAliveTime（线程存活保持时间）当线程池中线程数大于核心线程数时，线程的空闲时间如果超过线程存活时间，那么这个线程就会被销毁，直到线程池中的线程数小于等于核心线程数。
    4、workQueue（任务队列）：用于传输和保存等待执行任务的阻塞队列。
    5、threadFactory（线程工厂）：用于创建新线程。threadFactory创建的线程也是采用new Thread()方式，threadFactory创建的线程名都具有统一的风格：pool-m-thread-n（m为线程池的编号，n为线程池内的线程编号）。
    6、handler（线程饱和策略）：当线程池和队列都满了，再加入线程会执行此策略。 ```java package com.qf.juc01;

import java.util.concurrent.*;

public class TestThreadPool {

  1. public static void main(String[] args) {
  2.     int n = 3;
  4.     ThreadPoolExecutor poolExecutor =
  5.             new ThreadPoolExecutor(3, 5,
  6.                     1, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3)
  7.             );
  8.     for (int i=0;i<n;i++) {
  9.         poolExecutor.execute(new A1());
  10.     }
  11.     poolExecutor.shutdown();
  13. }

}

class A1 implements Runnable{

  1. @Override
  2. public void run() {
  3.     System.out.println(Thread.currentThread().getName()+": runnning" );
  4. }

}

  1. <a name="xTrbK"></a>
  2. ### 线程执行任务流程
  3. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/22969418/1635679534081-c4d33b78-3f16-4b9b-ba26-566de6c0d1b7.png#clientId=ua3837212-a861-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=uaacf3c68&margin=%5Bobject%20Object%5D&name=image.png&originHeight=410&originWidth=1323&originalType=binary&ratio=1&rotation=0&showTitle=false&size=442203&status=done&style=none&taskId=u36e770d4-f1b3-4662-a12c-b29aaa97edb&title=)
  4. <a name="YvVCw"></a>
  5. ### 线程池比较
  6. Excutors 类 创建线程池的方法 <br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/22969418/1635679568357-8aa6183e-846c-4b97-a607-37fdef2fec92.png#clientId=ua3837212-a861-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=uce11dc24&margin=%5Bobject%20Object%5D&name=image.png&originHeight=446&originWidth=1329&originalType=binary&ratio=1&rotation=0&showTitle=false&size=426770&status=done&style=none&taskId=u6fed1123-c9fd-4554-8b3b-2030a6ca2a0&title=)<br />1、newCachedThreadPool：用来创建一个可以无限扩大的线程池，适用于负载较轻的场景，执行短期异步任务。（可以使得任务快速得到执行，因为任务时间执行短，可以很快结束，也不会造成cpu过度切换）<br />2、newFixedThreadPool：创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于负载较重的场景，对当前线程数量进行限制。（保证线程数可控，不会造成线程过多，导致系统负载更为严重）<br />3、newSingleThreadExecutor：创建一个单线程的线程池，适用于需要保证顺序执行各个任务。<br />4、newScheduledThreadPool：适用于执行延时或者周期性任务。
  8. ```java
  9. public class ExcutorsDemo {
  12.     public static void main(String[] args) throws InterruptedException {
  14. //        final ExecutorService pool = Executors.newFixedThreadPool(8);
  16.         final ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
  19. //        for (int i=0;i<800;i++) {
  20. //            scheduledExecutorService.execute(new Runnable() {
  21. //                @Override
  22. //                public void run() {
  23. //                    System.out.println(Thread.currentThread().getName());
  24. //                }
  25. //            });
  26. //        }
  28. //        scheduledExecutorService.schedule(new Runnable() {
  29. //            @Override
  30. //            public void run() {
  31. //                System.out.println(Thread.currentThread().getName()+":hello delay queue");
  32. //            }
  33. //        },3, TimeUnit.SECONDS);
  36.         // 延迟执行任务，从任务提交开始，延迟1秒后执行；执行第一次后，每隔3秒钟再执行一次任务
  37.         scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
  38.             @Override
  39.             public void run() {
  40.                 System.out.println(Thread.currentThread().getName()+":hello delay queue");
  41.             }
  42.         },1,3,TimeUnit.SECONDS);
  46. //        Thread.sleep(100);
  47. //        System.out.println(scheduledExecutorService);
  48. //
  49. //
  50. //        scheduledExecutorService.shutdown();
  52.     }
  53. }

execute()和submit()方法

execute()，执行一个任务，没有返回值。submit()，提交一个线程任务，有返回值。submit(Callable task)能获取到它的返回值，通过future.get()获取（阻塞直到任务执行完）。submit(Runnable task)则是没有返回值的，就算获取它的返回值也是null
Future.get方法会使取结果的线程进入阻塞状态，知道线程执行完成之后，唤醒取结果的线程，然后返回结果。

  1. public class CallableDemo {
  2.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  4.         final ExecutorService pool = Executors.newFixedThreadPool(8);
  6.         // 异步处理任务
  7.         final Future<User> future = pool.submit(new Callable<User>() {
  8.             @Override
  9.             public User call() throws Exception {
  10.                 Thread.sleep(1000);
  11.                 final User user = new User();
  12.                 user.setId(1);
  13.                 user.setName("jack");
  15.                 return user;
  16.             }
  17.         });
  19.         System.out.println(" main 线程已经提交了任务 ");
  20.         // 如果这时主线程一定要获取到之前提交的任务的结果，那么可以再Future对象上调用get方法
  21.         // future对象调用get方法时，会让当前线程等待线程池把提交的任务执行完成，并返回结果
  22.         final User user = future.get(); // 该方法会让当前线程waiting
  23.         System.out.println(user);
  26.     }
  27. }