多线程之五种创建线程池的方式

你的名字 2023-02-20 12:24 54阅读 0赞

## 多线程之五种创建线程池的方式 ##

我们之前使用线程的时候都是使用new Thread来进行线程的创建，但是这样会有一些问题。如：

a. 每次new Thread新建对象性能差。  
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。  
c. 缺乏更多功能，如定时执行、定期执行、线程中断。  
相比new Thread，Java提供的四种线程池的好处在于：  
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。  
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。  
c. 提供定时执行、定期执行、单线程、并发数控制等功能。

而我们今天来学习和掌握另外一个新的技能，特别像一个线程池的一个接口类ExecutorService，下面我们来了解下java中Executors的线程池

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

在提几个线程池中的具体构造函数

corePoolSize : 核心线程数，一旦创建将不会再释放。如果创建的线程数还没有达到指定的核心线程数量，将会继续创建新的核心线程，直到达到最大核心线程数后，核心线程数将不在增加；如果没有空闲的核心线程，同时又未达到最大线程数，则将继续创建非核心线程；如果核心线程数等于最大线程数，则当核心线程都处于激活状态时，任务将被挂起，等待空闲线程来执行。

maximumPoolSize : 最大线程数，允许创建的最大线程数量。如果最大线程数等于核心线程数，则无法创建非核心线程；如果非核心线程处于空闲时，超过设置的空闲时间，则将被回收，释放占用的资源。

keepAliveTime : 也就是当线程空闲时，所允许保存的最大时间，超过这个时间，线程将被释放销毁，但只针对于非核心线程。

unit : 时间单位，TimeUnit.SECONDS等。

workQueue : 任务队列，存储暂时无法执行的任务，等待空闲线程来执行任务。

threadFactory : 线程工程，用于创建线程。

handler : 当线程边界和队列容量已经达到最大时，用于处理阻塞时的程序

下面上代码简单看下

CachedThread：

public class CachedThread {
        
        public static void main(String[] args) {
        
    
            ExecutorService cachedThread = Executors.newCachedThreadPool();
    
            for (int i = 0; i < 10; i++) {
        
                int index = i;
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                cachedThread.execute(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println("CachedThread----->"+index);
                    }
                });
    
            }
        }
    }

输出：

CachedThread----->0
    CachedThread----->1
    CachedThread----->2
    CachedThread----->3
    CachedThread----->4
    CachedThread----->5
    CachedThread----->6
    CachedThread----->7
    CachedThread----->8
    CachedThread----->9

FixedThread：

public class FixedThread {
        
        public static void main(String[] args) {
        
            ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
            for (int i = 0; i <10 ; i++) {
        
                int index = i;
    
                try {
        
                    System.out.println("FixedThread------>"+index);
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                fixedThreadPool.execute(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println("FixedThread------>"+index);
                    }
                });
            }
        }
    }

输出：

FixedThread------>0
    FixedThread------>1
    FixedThread------>0
    FixedThread------>2
    FixedThread------>1
    FixedThread------>3
    FixedThread------>2
    FixedThread------>4
    FixedThread------>3
    FixedThread------>5
    FixedThread------>4
    FixedThread------>6
    FixedThread------>5
    FixedThread------>7
    FixedThread------>6
    FixedThread------>8
    FixedThread------>7
    FixedThread------>9
    FixedThread------>8
    FixedThread------>9

ScheduledThread：

public class ScheduledThread {
        
        public static void main(String[] args) {
        
            ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
            for (int i = 0; i < 2; i++) {
        
                int index = i;
    
                scheduledThreadPool.schedule(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println("ScheduledThread--延迟3秒执行一个线程----->"+index);
                    }
                }, 2, TimeUnit.SECONDS);
    
                scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println("ScheduledThread--延迟1秒执行且每隔2秒执行一次线程----->"+index);
                    }
                }, 1, 2, TimeUnit.SECONDS);
    
            }
        }
    
    }

输出：

ScheduledThread--1秒执行一次线程----->0
    ScheduledThread--1秒执行一次线程----->1
    ScheduledThread--3秒执行一个线程----->0
    ScheduledThread--3秒执行一个线程----->1
    ScheduledThread--1秒执行一次线程----->0
    ScheduledThread--1秒执行一次线程----->1
    ScheduledThread--1秒执行一次线程----->0
    ScheduledThread--1秒执行一次线程----->1
    ScheduledThread--1秒执行一次线程----->0
    ScheduledThread--1秒执行一次线程----->1

SingleThread：

public class SingleThread {
        
        public static void main(String[] args) {
        
            ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
            for (int i = 0; i <10 ; i++) {
        
                int index = i;
                singleThreadExecutor.execute(new Runnable() {
        
                    @Override
                    public void run() {
        
                        try {
        
                            System.out.println("SingleThread------>"+index);
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
    }

SingleThread------>0
    SingleThread------>1
    SingleThread------>2
    SingleThread------>3
    SingleThread------>4
    SingleThread------>5
    SingleThread------>6
    SingleThread------>7
    SingleThread------>8
    SingleThread------>9

还有一个是WorkStealing ，明天再说这个  
喜欢的下伙伴可以关注我微信公众号哈，每天都有分享  
![在这里插入图片描述][20200627010527513.jpg_pic_center]

[20200627010527513.jpg_pic_center]: https://img-blog.csdnimg.cn/20200627010527513.jpg#pic_center