Java并发编程：Java的四种线程池的使用，以及自定义线程工厂

左手的ㄟ右手 2021-09-19 14:08 234阅读 0赞

**引言**

通过前面的文章，我们学习了Executor框架中的核心类ThreadPoolExecutor ，对于线程池的核心调度机制有了一定的了解，并且成功使用ThreadPoolExecutor 创建了线程池。

而在Java中，除了ThreadPoolExecutor ，Executor框架中还提供了四种线程池，这四种线程池都是直接或间接配置ThreadPoolExecutor的参数实现的，对于ThreadPoolExecutor类不熟悉的读者可以参考[Java并发编程：Java线程池核心ThreadPoolExecutor的使用和原理分析][Java_Java_ThreadPoolExecutor]

## 四种线程池 ##

四种线程池分别是：newCachedThreadPool、newFixedThreadPool 、newScheduledThreadPool 和newSingleThreadExecutor ，下面对这几个线程池一一讲解。

**如果你对编程感兴趣或者想往编程方向发展，可以关注微信公众号【筑梦编程】，大家一起交流讨论！小编也会每天定时更新既有趣又有用的编程知识！**

### newCachedThreadPool：可缓存的线程池 ###

**源码：**

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

newCachedThreadPool的方法中是返回一个ThreadPoolExecutor实例，从源码中可以看出该线程池的特点：

1、该线程池的核心线程数量是0，线程的数量最高可以达到**Integer** 类型最大值；

2、创建ThreadPoolExecutor实例时传过去的参数是一个SynchronousQueue实例，说明在创建任务时，若存在空闲线程就复用它，没有的话再新建线程。

3、线程处于闲置状态超过60s的话，就会被销毁。

**用法：**

public static void main(String[] args) {
        //定义ExecutorService实例
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            try {
                Thread.sleep(index * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //调用execute方法
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread() + ":" + index);
                }
            });
        }
    }

上面的代码因为每次循环都是隔一秒执行，这个时间足够之前的线程工作完毕，并在新循环中复用这个线程，程序的运行结果如下：

Thread[pool-1-thread-1,5,main]:0
    Thread[pool-1-thread-1,5,main]:1
    Thread[pool-1-thread-1,5,main]:2
    Thread[pool-1-thread-1,5,main]:3
    Thread[pool-1-thread-1,5,main]:4
    Thread[pool-1-thread-1,5,main]:5
    Thread[pool-1-thread-1,5,main]:6
    Thread[pool-1-thread-1,5,main]:7
    Thread[pool-1-thread-1,5,main]:8
    Thread[pool-1-thread-1,5,main]:9

### newFixedThreadPool：定长线程池 ###

**源码：**

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

线程池特点：

1、线程池的最大线程数等于核心线程数，并且线程池的线程不会因为闲置超时被销毁。

2、使用的列队是**LinkedBlockingQueue**，表示如果当前线程数小于核心线程数，那么即使有空闲线程也不会复用线程去执行任务，而是创建新的线程去执行任务。如果当前执行任务数量大于核心线程数，此时再提交任务就在队列中等待，直到有可用线程。

**用法：**

public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            try {
                Thread.sleep(index * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread() + ":" + index);
                }
            });
        }
    }

定义一个线程数为3的线程池，循环10次执行，可以发现运行的线程永远只有三个，结果如下：

Thread[pool-1-thread-1,5,main]:0
    Thread[pool-1-thread-2,5,main]:1
    Thread[pool-1-thread-3,5,main]:2
    Thread[pool-1-thread-1,5,main]:3
    Thread[pool-1-thread-2,5,main]:4
    Thread[pool-1-thread-3,5,main]:5
    Thread[pool-1-thread-1,5,main]:6
    Thread[pool-1-thread-2,5,main]:7
    Thread[pool-1-thread-3,5,main]:8
    Thread[pool-1-thread-1,5,main]:9

### newSingleThreadExecutor：单线程线程池 ###

**源码：**

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

从源码就可以看出，该线程池基本就是只有一个线程数的**newFixedThreadPool**，它只有一个线程在工作，所有任务按照指定顺序执行。

**用法：**

和newFixedThreadPool类似，只是一直只有一个线程在工作，这里就不贴代码了。

### newScheduledThreadPool：支持定时的定长线程池 ###

**源码：**

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    
    public ScheduledThreadPoolExecutor(int corePoolSize) {
            super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
                  new DelayedWorkQueue());
    }
    public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue) {
            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                 Executors.defaultThreadFactory(), defaultHandler);
        }

newScheduledThreadPool的方法不是直接返回一个ThreadPoolExecutor实例，而是通过有定时功能的ThreadPoolExecutor，也就是`ScheduledThreadPoolExecutor` 来返回ThreadPoolExecutor实例，从源码中可以看出：

1、该线程池可以设置核心线程数量，最大线程数与newCachedThreadPool一样，都是Integer.MAX\_VALUE。

2、该线程池采用的队列是DelayedWorkQueue，具有延迟和定时的作用。

**用法：**

public static void main(String[] args) {
        ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
    
        //延迟3秒执行，只执行一次
        ((ScheduledExecutorService) scheduledThreadPool).schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟========");
            }
        },3,TimeUnit.SECONDS);
    
        //延迟1秒后每隔两秒执行一次
        ((ScheduledExecutorService) scheduledThreadPool).scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行============");
            }
        },1,2,TimeUnit.SECONDS);            //单位是秒
    }

## 自定义ThreadFactory ##

四种线程池的使用就说到这里了，值得说明的是，除了上面的参数外，Executors类中还给这四种线程池提供了可传`ThreadFactory`的重载方法，以下是它们的源码：

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                    60L, TimeUnit.SECONDS,
                                    new SynchronousQueue<Runnable>(),
                                    threadFactory);
    }
    public static ScheduledExecutorService newScheduledThreadPool(
                    int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }
    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>(),
                                          threadFactory);
    }

ThreadFactory是一个接口类，也就是我们经常说的线程工厂，只有一个方法，可以用于创建线程：

Thread newThread(Runnable r);

默认情况下，ThreadPoolExecutor构造器传入的`ThreadFactory` 参数是Executors类中的defaultThreadFactory()，相当于一个线程工厂，帮我们创建了线程池中所需的线程。

除此之外，我们也可以自定义ThreadFactory，并根据自己的需要来操作线程，下面是实例代码：

public static void main(String[] args) {
        ExecutorService service = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
                new SynchronousQueue<Runnable>(), new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread t = new Thread(r);
                System.out.println("我是线程" + r);
                return t;
            }
        }
        );
        //用lambda表达式编写方法体中的逻辑
        Runnable run = () -> {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "正在执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        for (int i = 0; i < 5; i++) {
            service.submit(run);
        }
        //这里一定要做关闭
        service.shutdown();
    }

运行代码后，控制行会输出五行 “我是线程java.util.concurrent.ThreadPoolExecutor。。。。。”的信息，也证明了我们自定义的ThreadFactory起到了作用。

[Java_Java_ThreadPoolExecutor]: https://www.cnblogs.com/yeya/p/10218358.html