多线程 - 12.线程池

为什么要使用线程池

1. 减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存

使用newFixedThreadPool线程池

newFixedThreadPool 将创建一个固定长度的线程池

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class test0 {
    public static void main(String[] args){
        ExecutorService executor = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 4; i++){
            Runnable runnable = new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行");
                }
            };
            executor.execute(runnable);
        }
        executor.shutdown();
    }
}

pool-1-thread-1正在执行
pool-1-thread-2正在执行
pool-1-thread-3正在执行
pool-1-thread-3正在执行

使用newCachedThreadPool线程池

newCachedThreadPool 将创建一个可缓存的线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class test0 {
    public static void main(String[] args){
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 4; i++){
            Runnable runnable = new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行");
                }
            };
            executor.execute(runnable);
        }
        executor.shutdown();
    }
}

pool-1-thread-1正在执行
pool-1-thread-3正在执行
pool-1-thread-2正在执行
pool-1-thread-4正在执行

使用newSingleThreadExecutor线程池

newSingleThreadExecutor 能确保依照任务在队列中的顺序来串行执行

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class test0 {
    public static void main(String[] args){
        ExecutorService executor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 4; i++){
            Runnable runnable = new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行");
                }
            };
            executor.execute(runnable);
        }
        executor.shutdown();
    }
}

pool-1-thread-1正在执行
pool-1-thread-1正在执行
pool-1-thread-1正在执行
pool-1-thread-1正在执行

使用newScheduledThreadPool线程池

newScheduledThreadPool 创建了一个固定长度的线程池，而且以延迟或定时或周期的方式来执行任务，类似于 Timer、定时任务。可应用于重发机制。此代码会无限循环输出。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class test0 {
    public static void main(String[] args){
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(3);
        for (int i = 0; i < 2; i++){
            final int index = i;
            Runnable runnable = new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "延时 1s 后，每 2s 执行一次工作任务--- >" + index);
                }
            };
            executor.scheduleAtFixedRate(runnable,1,2,TimeUnit.SECONDS);
        }
        if (executor.isShutdown()) {
            executor.shutdown();
        }
    }
}

pool-1-thread-1延时 1s 后，每 2s 执行一次工作任务— >0
pool-1-thread-2延时 1s 后，每 2s 执行一次工作任务— >1
pool-1-thread-2延时 1s 后，每 2s 执行一次工作任务— >0
pool-1-thread-1延时 1s 后，每 2s 执行一次工作任务— >1
pool-1-thread-3延时 1s 后，每 2s 执行一次工作任务— >0
pool-1-thread-2延时 1s 后，每 2s 执行一次工作任务— >1
pool-1-thread-1延时 1s 后，每 2s 执行一次工作任务— >0
pool-1-thread-3延时 1s 后，每 2s 执行一次工作任务— >1
pool-1-thread-2延时 1s 后，每 2s 执行一次工作任务— >0
… …

常用的使用方法是调用 Executors 中的静态方法来创建一个连接池。java 自带的线程池仅有 4 种：

• newFixedThreadPool
• newCachedThreadPool
• newSingleThreadExecutor
• newScheduledThreadPool

以上四种创建线程池的方法其实都是调用java.util.concurrent.ThreadPoolExecutor 的构造函数，只是参数不一样：

• corePoolSize : 核心线程数
• maximumPoolSize : 最大线程数
• keepAliveTime : 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间
• unit : 时间单位
• workQueue : 用于存储工作工人的队列
• threadFactory : 创建线程的工厂
• handler : 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序

常用的几种队列

• ArrayBlockingQueue：规定大小的 BlockingQueue ， 其构造必须指定大小。其所含的对象是 FIFO 顺序排序的。
• LinkedBlockingQueue ： 大小不固定的 BlockingQueue ， 若其构造时指定大小，生成的 BlockingQueue 有大小限制，不指定大小，其大小有 Integer.MAX_VALUE 来决定。其所含的对象是 FIFO 顺序排序的。
• PriorityBlockingQueue ：类似于 LinkedBlockingQueue ， 但是其所含对象的排序不是 FIFO，而是依据对象的自然顺序或者构造函数的 Comparator 决定。
• SynchronizedQueue：特殊的 BlockingQueue，对其的操作必须是放和取交替完成。

排队策略

• 直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

• 无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。

• 有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量。