四大线程池详解

骑猪看日落 2022-06-09 07:28 149阅读 0赞

# [四大线程池详解 ][Link 1] #

标签： [ 线程池][Link 2][java][][Android][][thread][]

2017-08-30 17:47  735人阅读 [评论][Link 3](2) 收藏 [举报][Link 4]

![category_icon.jpg][] 分类：

java多线程*（4）* ![arrow_triangle_20_down.jpg][] ![arrow_triangle_up.jpg][]

[作者同类文章][Link 5] *X*

目录[(?)][Link 6][\[+\]][Link 6]

1.  [new Thread 的弊端][new Thread]
2.  [线程池的优点][Link 7]
3.  [newCachedThreadPool][]
4.  [newFixedThreadPool][]
5.  [newScheduledThreadPool][]
6.  [newSingleThreadExecutor][]

## new Thread 的弊端 ##

首先看一段代码：

/** * Created by Zero on 2017/8/30. */
    public class ThreadTest { 
        public static void main(String[] args) {
            while (true) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread());
                    }
                }).start();
            }
        }
    }

![save_snippets.png][]

Thread[Thread-0,5,main]
    Thread[Thread-4,5,main]
    Thread[Thread-3,5,main]
    Thread[Thread-6,5,main]
    Thread[Thread-7,5,main]
    Thread[Thread-2,5,main]
    Thread[Thread-1,5,main]
    Thread[Thread-8,5,main]
    Thread[Thread-9,5,main]
    Thread[Thread-5,5,main]
    Thread[Thread-10,5,main]
    Thread[Thread-11,5,main]
    Thread[Thread-12,5,main]
    Thread[Thread-13,5,main]
    ... ...

![save_snippets.png][]

先说一下此处的打印，第一个参数是当前线程名称，由于线程之间是异步执行，有的还没创建好，有的后来居上就执行完了，导致打印线程的名称会这样，第二个参数是优先级，默认都是5，第三个参数是线程组名称。

如果不停止程序，这段代码会不断创建和销毁线程，直到死机或者OOM，更尴尬的是此处的线程，还无法主动去中断。

上述的线程启动方式在日常开发中经常看到的，但是从性能和优化的角度来说，问题还真不小。

> 1.  每次都新建，性能较差(这个在[线程池原理][Link 8]中有详细讲解)。
> 2.  线程缺乏统一管理，可能无限制的创建线程，互相竞争，会带来一些不必要的麻烦。
> 3.  可控性太差，比如定时定期执行，比如[线程中断机制][Link 9]。

## 线程池的优点 ##

[Java][]提供了四大线程池，主要针对new Thread的弊端讲述优点：

> 1.  降低资源消耗，不需要每次都是新建和销毁，性能得到了提高。
> 2.  统一管理，可有效控制最大并发量，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
> 3.  可控性很好，可以定期定时执行、线程中断机制等。

## newCachedThreadPool ##

newCachedThreadPool：创建带有缓存的线程池。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /** * Created by Zero on 2017/8/30. */
    public class ThreadTest { 
        public static void main(String[] args) {
            test();
        }
    
        private static void test(){
            ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
            for (int i = 0; i < 100; i++) {
    
                cachedThreadPool.execute(new Runnable() {
    
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread());
                    }
                });
            }
        }
    }

![save_snippets.png][]

Thread[pool-1-thread-2,5,main]
    Thread[pool-1-thread-4,5,main]
    Thread[pool-1-thread-3,5,main]
    Thread[pool-1-thread-6,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-5,5,main]
    Thread[pool-1-thread-7,5,main]
    Thread[pool-1-thread-7,5,main]
    Thread[pool-1-thread-5,5,main]
    Thread[pool-1-thread-3,5,main]
    Thread[pool-1-thread-4,5,main]
    Thread[pool-1-thread-7,5,main]
    Thread[pool-1-thread-6,5,main]
    Thread[pool-1-thread-4,5,main]
    ... ...

由此可见，上述线程在新建的同时，还有部分线程被回收后再利用，刚刚做了下[测试][Link 10]，在每次打印之前加了2ms的延迟，打印的都是“Thread\[pool-1-thread-1,5,main\]”。

**线程池为无限大(其实是Interger. MAX\_VALUE)，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程**。

## newFixedThreadPool ##

newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /** * Created by Zero on 2017/8/30. */
    public class ThreadTest { 
        public static void main(String[] args) {
            test();
        }
    
        private static void test(){
            ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
            for (int i = 0; i < 100; i++) {
    
                fixedThreadPool.execute(new Runnable() {
    
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread());
                    }
                });
            }
        }
    }

![save_snippets.png][]

Thread[pool-1-thread-2,5,main]
    Thread[pool-1-thread-3,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-3,5,main]
    Thread[pool-1-thread-3,5,main]
    Thread[pool-1-thread-2,5,main]
    Thread[pool-1-thread-3,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-2,5,main]
    Thread[pool-1-thread-3,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-3,5,main]
    Thread[pool-1-thread-2,5,main]
    ... ...

此处配置最大的线程长度是3，由打印可看出，此处始终在三个线程中执行。

## newScheduledThreadPool ##

newScheduledThreadPool：支持定时和周期性执行的线程池。

import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    /** * Created by Zero on 2017/8/30. */
    public class ThreadTest { 
        public static void main(String[] args) {
            test();
        }
    
        private static void test(){
            ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
            /** * 延迟3秒执行 */
            scheduledThreadPool.schedule(new Runnable() {
    
                @Override
                public void run() {
                    System.out.println(Thread.currentThread());
                }
            }, 3000, TimeUnit.MILLISECONDS);
    
            /** * 延迟1秒后每3秒执行一次 */
            scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
    
                @Override
                public void run() {
                    System.out.println(Thread.currentThread());
                }
            }, 1, 3000, TimeUnit.MILLISECONDS);
        }
    }

Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-2,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-1,5,main]
    Thread[pool-1-thread-2,5,main]
    Thread[pool-1-thread-2,5,main]
    ... ...

此方法无论任务执行时间长短，都是当第一个任务执行完成之后，延迟指定时间再开始执行第二个任务。

在日常开发中，newScheduledThreadPool可以作为timer的替代品，对比timer，newScheduledThreadPool更安全更强大。

## newSingleThreadExecutor ##

newSingleThreadExecutor：从名称上便可以看出，此线程池是一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序。如果这个线程异常结束，会有另一个取代它，保证顺序执行(我觉得这点是它的特色)。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /** * Created by Zero on 2017/8/30. */
    public class ThreadTest { 
        public static void main(String[] args) {
            test();
        }
    
        private static void test(){
            ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
            for (int i = 0; i < 100; i++) {
                singleThreadExecutor.execute(new Runnable() {
    
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread());
                    }
                });
            }
        }
    }

得到的结果会一直是“Thread\[pool-1-thread-1,5,main\]”。

总结：对于任务量少或者只有一个任务的情况下，此时使用线程池显得高射炮打蚊子了，但是对于任务量多，单个任务处理的时间比较短的情况下，你会对线程池有不一样的体会和好感。

友情推荐：

1.  [线程池原理][Link 8]
2.  [深入Thread.sleep][Thread.sleep]
3.  [多线程中断机制][Link 9]
4.  [head first Thread.join()][head first Thread.join]

[Link 1]: http://blog.csdn.net/pangpang123654/article/details/77720036
[Link 2]: http://www.csdn.net/tag/%e7%ba%bf%e7%a8%8b%e6%b1%a0
[java]: http://www.csdn.net/tag/java
[Android]: http://www.csdn.net/tag/Android
[thread]: http://www.csdn.net/tag/thread
[Link 3]: http://blog.csdn.net/pangpang123654/article/details/77720036#comments
[Link 4]: http://blog.csdn.net/pangpang123654/article/details/77720036#report
[category_icon.jpg]: /images/20220609/cbb0b74a2f36440193cd8adac7f48c35.png
[arrow_triangle_20_down.jpg]: http://static.blog.csdn.net/images/arrow_triangle%20_down.jpg
[arrow_triangle_up.jpg]: /images/20220609/33919dbf5c4e4a05a22323b89f717d44.png
[Link 5]: http://blog.csdn.net/pangpang123654/article/category/7058320
[Link 6]: http://blog.csdn.net/pangpang123654/article/details/77720036#
[new Thread]: http://blog.csdn.net/pangpang123654/article/details/77720036#t0
[Link 7]: http://blog.csdn.net/pangpang123654/article/details/77720036#t1
[newCachedThreadPool]: http://blog.csdn.net/pangpang123654/article/details/77720036#t2
[newFixedThreadPool]: http://blog.csdn.net/pangpang123654/article/details/77720036#t3
[newScheduledThreadPool]: http://blog.csdn.net/pangpang123654/article/details/77720036#t4
[newSingleThreadExecutor]: http://blog.csdn.net/pangpang123654/article/details/77720036#t5
[save_snippets.png]: /images/20220609/c8f96342dc734b4d820da85a96079591.png
[Link 8]: http://blog.csdn.net/pangpang123654/article/details/75949823
[Link 9]: http://blog.csdn.net/pangpang123654/article/details/77336383
[Java]: http://lib.csdn.net/base/java
[Link 10]: http://lib.csdn.net/base/softwaretest
[Thread.sleep]: http://blog.csdn.net/pangpang123654/article/details/77006244
[head first Thread.join]: http://blog.csdn.net/pangpang123654/article/details/77532451