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

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

我们之前使用线程的时候都是使用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 ，明天再说这个
喜欢的下伙伴可以关注我微信公众号哈，每天都有分享