Java☞线程池

java.util.concurrent.Executors类
java.util.concurrent.Executor接口
二者很相似，但是创建线程池的话都是通过实现接口的方式，多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。
假设一个服务器完成一项任务所需时间为：T1创建线程时间，T2在线程中执行任务时间，T3销毁线程时间。
如果：T1 + T3 远大于T2， 则应该采用线程池，用于提高服务器性能。
一个线程池包括以下四个基本组成部分：

1. 线程池 管理器（ThreadPoll）：用于创建并管理线程池，包括创建线程池，销毁线程池，添加任务；
2. 工作线程（PoolWorker）：线程池中的线程，在没有任务时处于等待状态，可以循环的执行任务；
3. 任务接口（Task）：每个任务必须实现的接口，以提供线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
4. 任务队列（taskQueue）：用于存放没有处理的任务，提供一种缓冲机制。
   线程池技术正是关注如何缩短或调整T1、T3时间的技术，从而提高服务器程序性能。

常见线程池

1. newSingleThreadExecutor
   单个线程的线程池，即线程池中每次只有一个线程工作，单线程串行执行任务
2. newFixedThreadExecutor(n)
   固定数量的线程池，每提交一个任务就是一个线程，直到达到线程池的最大数量，然后后面进入等待队列直到前面的任务完成才继续执行
3. newCacheThreadExecutor（推荐使用）[无界线程池，可以进行自动线程回收]
   可缓存线程池，当线程池大小超过了处理任务所需的线程，那么就会回收部分空闲（一般是60秒无执行）的线程，当有任务来时，又智能的添加新线程来执行。
4. newScheduleThreadExecutor
   大小无限制的线程池，支持定时和周期性的执行线程
   为什么使用线程池？
   创建线程和销毁线程的花销是比较大的，这些时间有可能比处理业务的时间还要长。这样频繁的创建线程和销毁线程，再加上业务工作线程，消耗系统资源的时间，可能导致系统资源不足。
   线程池作用（优点）
   线程池的作用就是限制系统中执行线程的数量，根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。
   1、提高效率 创建好一定数量的线程放在池中，等需要使用的时候就从池中拿一个，这要比需要的时候创建一个线程对象要快的多。（减少了创建和销毁线程的次数）
   2、方便管理 可以编写线程池管理代码对池中的线程同一进行管理，比如说启动时有该程序创建100个线程，每当有请求的时候，就分配一个线程去工作，如果刚好并发有101个请求，那多出的这一个请求可以排队等候，避免因无休止的创建线程导致系统崩溃。

几个常用来接收线程池对象的类或者接口
ExecutorService 是真正的线程池接口，创建的一般线程池对象我们一般就用它接收。

public interface ExecutorService extends Executor {}

---

ScheduledExecutorService 接口继承了ExecutorService接口，它用来解决那些需要任务重复执行的问题。

public interface ScheduledExecutorService extends ExecutorService {}

---

类ThreadPoolExecutor是ExecutorService接口的默认实现类。

public class ThreadPoolExecutor extends AbstractExecutorService {}

---

类ScheduledThreadPoolExecutor继承了ThreadPoolExecutor类，并实现了ScheduledExecutorService接口，因此该类能执行 一些周期性调度的方法。

public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService {}

常见线程池的创建方法源码如下

package cn.ihep.threadPool;

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

import org.junit.Test;

/**
 * 常见线程池创建
 * 
 * @author xiaoming
 *
 */
public class ThreadPoolTest {

    class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    }

    @Test
    public void singleThreadExcutor() {
        // 创建单线程池
        ExecutorService pool = Executors.newSingleThreadExecutor();
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        MyThread t4 = new MyThread();
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);

        // 关闭线程池
        pool.shutdown();
    }
--------------
输出：
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
---------------

    @Test
    public void fixedThreadExecutor() {
        int capacity = 10;
        ExecutorService pool = Executors.newFixedThreadPool(capacity);
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        MyThread t4 = new MyThread();

        // 将线程放入线程池执行
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);

        // 关闭线程池
        pool.shutdown();
    }
-------------------
输出结果：
pool-1-thread-1
pool-1-thread-3
pool-1-thread-4
pool-1-thread-2
-------------------

    @Test
    public void cacheThreadExecutor() {
        ExecutorService pool = Executors.newCachedThreadPool();
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        MyThread t4 = new MyThread();
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);

        // 关闭线程池
        pool.shutdown();
    }
--------------------
输出结果：
pool-1-thread-1
pool-1-thread-3
pool-1-thread-4
pool-1-thread-2
--------------------

    //newScheduledThreadPool线程池的实现
    public static void main(String[] args) {
        int corePoolSize = 10;
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(corePoolSize);
        pool.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                // 打印系统时间
                System.out.println("*****************");
            }
        }, 1000, 1000 * 5, TimeUnit.MILLISECONDS);

        pool.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println(System.nanoTime());
            }
        }, 1000, 2000, TimeUnit.MILLISECONDS);
    }
---------------------------
输出结果：
*****************
302010811506149
302012811595099
302014811621613
*****************
302016811745346
302018811897303
*****************
302020810967599
... ...
---------------------------
}

---

线程池有哪几种工作队列

1. ArrayBlockingQueue
   是一个基于数组结构的有界阻塞队列，此队列按FIFO原则对元素进行排序。
2. LinkedBlockingQueue
   一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFiexedThreadPool()使用了这个队列
3. SynchronousQueue
   一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCacheThreadPool使用了这个队列
4. PriorityBlockingQueue
   一个具有优先级的无限阻塞队列

---

怎么理解有界/无界队列

有界队列
1.初始的poolSize < corePoolSize，提交的runnable任务，会直接做为new一个Thread的参数，立马执行 。
2.当提交的任务数超过了corePoolSize，会将当前的runable提交到一个block queue中。
3.有界队列满了之后，如果poolSize < maximumPoolsize时，会尝试new 一个Thread的进行救急处理，立马执行对应的runnable任务。
4.如果3中也无法处理了，就会走到第四步执行reject操作。
无界队列
与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败的情况。当有新的任务到来，系统的线程数小于corePoolSize时，则新建线程执行任务。当达到corePoolSize后，就不会继续增加，若后续仍有新的任务加入，而没有空闲的线程资源，则任务直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统内存。