Java多线程初阶-线程池总结

小咪咪 2023-09-27 17:12 30阅读 0赞

## 一、什么是线程池？ ##

**线程池是一种管理线程的机制，用于复用线程资源，减少线程创建和销毁的开销，从而提高程序性能；线程池中的线程在完成任务后不会立即销毁，而是被放回线程池，等待执行新的任务**

## 二、线程池参数介绍 ##

ThreadPoolExecutor构造方法：

public ThreadPoolExecutor(int corePoolSize, //核心线程数量
                                  int maximumPoolSize,//     最大线程数
                                  long keepAliveTime, //       最大空闲时间
                                  TimeUnit unit,         //        时间单位
                                  BlockingQueue<Runnable> workQueue,   //   任务队列
                                  ThreadFactory threadFactory,    // 线程工厂
                                  RejectedExecutionHandler handler  //  饱和处理机制
    	)

> **1.核心线程数（corePoolSize）:线程池中始终保持的线程数.当线程池中的线程数小于核心线程数时,即使有空闲线程,新任务也会创建新的线程执行.**
> 
>  **2.最大线程数（maximumPoolSize）:线程池中允许的最大线程数.**
> 
>  **3.工作队列（workQueue）:用于存储等待执行的任务的阻塞队列。当核心线程数满时，新任务会进入工作队列等待执行。**
> 
>  **4.线程空闲时间（keepAliveTime）：当线程池中的线程数大于核心线程数时，多余的空闲线程在等待新任务的最长时间。超过这个时间，空闲线程将被销毁。**
> 
>  **5.线程工厂（ThreadFactory）:用于创建新线程的工厂对象。**
> 
>  **6.拒绝策略（RejectedExecutionHandler）:当线程池无法处理新任务时采取的拒绝策略**.

> **拒绝策略**
> 
>  **1.AbortPolicy（默认）:直接抛出RejectedExecutionException异常,不执行被拒绝的任务**
> 
>  **2.CallerRunsPolicy:将被拒绝的任务交给调用线程池的线程（通常是主线程）来执行。这种策略可以降低新任务提交的速度，从而为线程池腾出时间来处理更多任务.**
> 
>  **3.DiscardPolicy:当新任务被提交后直接被丢弃掉,不执行也不抛出异常.**
> 
>  **4.DiscardOldestPolicy:丢弃工作队列中最旧的任务,然后将新任务添加到工作队列中.如果队列中的任务是有序的或存在依赖关系,这种策略可能导致问题.**

## 三、线程池工作流程 ##

当有新任务提交时,线程池会根据核心线程数创建新线程来执行任务.

如果当前线程数达到核心线程数,新任务会被放入工作队列中.

如果工作队列已满,线程池会创建新线程来执行任务,直到线程数达到最大线程数.

如果线程数已达到最大线程数且工作队列已满,线程池会根据拒绝策略处理新任务.

当线程池中的线程数大于核心线程数且空闲时间超过keepAliveTime时,多余的空闲线程将被销毁.

## 四、使用Executors创建常见线程池 ##

Java通过**Executors工厂类提供四种线程池**，分别为：

1.  **newCachedThreadPool** ：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，否则新建线程。（线程最大并发数不可控制）
2.  **newFixedThreadPool**：创建一个固定大小的线程池，可控制线程最大并发数，超出的线程会在队列中等待。
3.  **newScheduledThreadPool** ： 创建一个定时线程池，支持定时及周期性任务执行。
4.  **newSingleThreadExecutor** ：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

### newCachedThreadPool ###

public class CachedThreadPoolTest {
    
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newCachedThreadPool();
            MyRunnable myRunnable = new MyRunnable();
            for (int i = 0; i < 5; i++) {
                executorService.execute(myRunnable);
            }
    
            System.out.println("线程任务开始执行");
            executorService.shutdown();
        }
    
    }
    
    public class MyRunnable implements Runnable {
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is running...");
        }
    
    }

源码：

public static ExecutorService newCachedThreadPool() {
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>());
            
        }

通过上面的源码我们可以看到，newCachedThreadPool没有核心线程个数，就像一个餐厅，招聘的全是临时工，而且它的非核心线程无上限，每个临时线程空闲时间只存活60秒

执行流程：

> 1.没有核心线程，直接向 SynchronousQueue 中提交任务
> 
>   
> 2.如果有空闲线程，就去取出任务执行；如果没有空闲线程，就新建一个
> 
>   
> 3.执行完任务的线程有 60 秒生存时间，如果在这个时间内可以接到新任务，就可以继续存在，否则就被回收掉了

**因为空闲 60 秒的线程就会被终止，长时间保持空闲的 CachedThreadPool 不会占用任何资源。**

### newFixedThreadPool ###

public class FixedThreadPoolTest {
    
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newFixedThreadPool(2);
            MyRunnable myRunnable = new MyRunnable();
            for (int i = 0; i < 5; i++) {
                executorService.execute(myRunnable);
            }
    
            System.out.println("线程任务开始执行");
            executorService.shutdown();
        }
    
    }
    
    public class MyRunnable implements Runnable {
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is running...");
        }
    
    }

源码：

public static ExecutorService newFixedThreadPool(int nThreads) {
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>());
        }

我们通过源码可以看到，FixedThreadPool 的核心线程数和最大线程数都是我们可以指定的， keepAliveTime 为 0，也就是多余的空余线程会被立即终止

执行流程：

> 1.  线程数少于核心线程数，也就是设置的线程数时，新建线程执行任务
> 2.  线程数等于核心线程数后，将任务加入阻塞队列
> 3.  由于队列容量非常大，可以一直加
> 4.  执行完任务的线程反复去队列中取任务执行

**FixedThreadPool 主要用于负载比较重的服务器，为了资源的合理利用，需要限制当前线程数量**。

### newScheduledThreadPool ###

public class ScheduledThreadPoolTest {
    
        public static void main(String[] args) {
            ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
            MyRunnable myRunnable = new MyRunnable();
            for (int i = 0; i < 5; i++) {
                // 参数1:目标对象,参数2:隔多长时间开始执行线程,参数3:执行周期,参数4:时间单位
                scheduledExecutorService.scheduleAtFixedRate(myRunnable, 1, 2, TimeUnit.SECONDS);
            }
    
            System.out.println("线程任务开始执行");
        }
    
    }
    
    public class MyRunnable implements Runnable {
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is running...");
        }
    
    }

### newSingleThreadExecutor ###

public class SingleThreadExecutorTest {
    
        public static void main(String[] args) {
            ExecutorService executorService = Executors.newSingleThreadExecutor();
            MyRunnable myRunnable = new MyRunnable();
            for (int i = 0; i < 5; i++) {
                executorService.execute(myRunnable);
            }
    
            System.out.println("线程任务开始执行");
            executorService.shutdown();
        }
    
    }
    
    public class MyRunnable implements Runnable {
    
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is running...");
        }
    
    }