线程池

[TOC]

1. 并发队列：阻塞队列和非阻塞队列

区别如下：

入队：

非阻塞队列：当队列中满了的时候，放入数据，数据丢失
阻塞队列：当队列满了的时候，进行等待，什么时候队列中有出队的数据，那么第 11 个再放进入

出队：

非阻塞队列：如果现在队列中没有元素，取数据，得到的是 null
阻塞队列：等待，什么时候放进去，再取出来

线程池是使用阻塞队列。

2. 线程池原理：ThreadPoolExecutor 底层原理解析

2. 1线程的生命周期

从出生到死亡的阶段。

2.2 线程池工作原理

ThreadPoolExecutor t = new ThreadPoolExecutor(1, 3, 0, TimeUnit.MICROSECONDS, new LinkedBlockingDeque<>(3));

参数含义：

1：核心线程数
3：最大线程数
0 和 TimeUnit.MICROSECONDS：当任务量大于队列长度需要创建线程的时候，新创建的这个线程假如把队列的任务都执行完了，那么等待新任务的空闲时间就是这个
new LinkedBlockingDeque<>(3))：阻塞队列：
- 方法有参数：队列长度为 3
- 方法无参数：队列长度为 Integer.MAX_VALUE

执行流程图如下所示：

2.3 举个例子

package com.test.jdk8;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPoolExecutor {

    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(1, 2, 3, TimeUnit.SECONDS, new LinkedBlockingDeque<>(3));
        // 利用线程池里的线程，开始执行任务
        // 执行第一个任务
        pool.execute(new TestThread());
        // 执行下面三个任务，放入阻塞队列，阻塞队列满：
        pool.execute(new TestThread());
        pool.execute(new TestThread());
        pool.execute(new TestThread());

        // 执行第 4个任务，创建新线程，分摊任务
        pool.execute(new TestThread());

        // 执行第 5 个任务，创建新创建，线程数大于最大线程数，报错
        pool.execute(new TestThread());


        // 关闭线程池
        pool.shutdown();
    }

}

class TestThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

3. 线程池的分类

1. newCachedThreadPool 可缓存线程池

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：

package ThreadTest;

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

public class Test {

    public static void main(String[] args) {
        ExecutorService es = Executors.newCachedThreadPool();

        for (int i = 0; i < 100; i++) {
            // lambda 表达式, 实现 new Runnable() 的 run() 方法
            es.execute(() -> System.out.println(Thread.currentThread().getName()));
        }

        es.shutdown();

    }

}

查看 newCachedThreadPool 源码，可知：

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

该线程池的核心线程数为 0，最大线程数为 Integer.MAX_VALUE，将会根据需要创建新线程，新线程的数量不大于 Integer.MAX_VALUE，线程执行任务结束后被释放可重复使用该线程执行另一个任务。

部分执行结果如下：

pool-1-thread-6
pool-1-thread-11
pool-1-thread-6
pool-1-thread-10
pool-1-thread-4
pool-1-thread-11
pool-1-thread-2

2. newFixedThreadPool 定长线程池

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

package ThreadTest;

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

public class Test {

    public static void main(String[] args) {
        ExecutorService es = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 100; i++) {
            // lambda 表达式, 实现 new Runnable() 的 run() 方法
            es.execute(() -> System.out.println(Thread.currentThread().getName()));
        }

        es.shutdown();

    }

}

查看 newFixedThreadPool 源码，可知：

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

传入的参数即为核心线程数和最大线程数，核心线程数和最大线程数的数量是相等的。

所以上述示例代码的执行结果的线程数就为 3，部分执行结果如下：

pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1

3. newScheduledThreadPool 定时线程池

创建一个定时线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

package ThreadTest;

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

public class Test {

    public static void main(String[] args) {
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(2);

        for (int i = 0; i < 100; i++) {
            ses.schedule(() -> System.out.println(Thread.currentThread().getName()), 3, TimeUnit.SECONDS);
        }

        ses.shutdown();

    }
}

查看 newScheduledThreadPool 源码，如下：

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

可知，newScheduledThreadPool 传入的参数即为核心线程数，最大线程数为 Integer.MAX_VALUE。

上述代码通过设置延迟参数 3，单位 TimeUnit.SECONDS，延迟三秒后执行任务，创建的线程数为 2。执行部分结果如下：

pool-1-thread-1
pool-1-thread-2
pool-1-thread-1
pool-1-thread-2
pool-1-thread-1

4. newSingleThreadExecutor 单例线程池

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

package ThreadTest;

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

public class Test {

    public static void main(String[] args) {
        ExecutorService es = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 100; i++) {
            es.execute(() -> System.out.println(Thread.currentThread().getName()));
        }

        es.shutdown();

    }
}

查看 newSingleThreadExecutor 源码，可知：

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

核心线程数和最大线程数都为 1，执行完任务后线程的存活时间为 0，即创建出来的线程只会执行一次任务，保证单例执行。

运行部分结果如下：

pool-1-thread-1
pool-1-thread-1
pool-1-thread-1

线程池

线程池

线程池