java 线程池（一） 概述

为什么要有线程池

线程的创建和销毁存在一定的开销，利用线程池技术可以提高资源利用效率。

java提供的线程池

一般利用Executors提供通用的线程池创建，创建不同配置的线程池。

       newCachedThreadPool() 

     用来处理大量短时间工作任务的线程池 比如 快算。

      它会试图去缓存线程并重用，当无缓存线程可用，会创建新的工作线程，如果线程闲置时间超过60秒会被终止并移出缓存，长时间闲置时这个线程池是不会带来什么资源消耗。内部采用SynchronousQueue 作为工作队列。

     newFixedThreadPool(int nThreads)

      重用指定数目的线程，使用的无界工作队列，任何时候最多只能有nThreads个工作线程是活动的，如果任务数量超过活动队列数目，会在工作队列中等待空闲线程出现。如果有工作线程退出，将会创建新的线程去补足指定的nThreads线程个数。

newSingleThreadExecutor()

     它的特点在于工作线程数目被限制为1，操作一个无界的工作队列，保证所有任务顺序执行，最多一个任务处于活跃状态，不允许使用者改变线程池实例而改变线程数目。

newSingleThreadScheduledExecutor() 和 newScheduledThreadPool(int corePoolSize) 

进行定时或周期性工作调度，前者是单一工作线程，后者是多个工作线程。创建的是ScheduledExecutorService

newWorkStealingPool(int parallelism)

jdk8引入，至此并行处理任务，不保证处理顺序。

应用方式

   

    Executor 一个基础的接口，将任务提交和任务执行细节解耦。

void execute(Runnable command);

ExecutorService 进一步完善，提供了service管理功能，如shutdown，也提供了全面的提交任务机制 如 返回Future而不是简单的void submit ，下面方法解决了Runnable无法返回结果的困扰。

<T> Future<T> submit(Callable<T> task);

java提供的几个标准实现：ThreadPoolExecutor、ScheduledThreadPoolExecutor、PoolExecutor、ForkJoinPool。这些线程池的设计理念在于高度的可调节性和灵活性，满足复杂的应用常见。

工作队列

负责将用户提交的任务存入，这个工作队列初识容量可以是为0的SynchronousQueue（newCachedThreadPool），也可以像用固定大小线程池（newFixedThreadPool）一样使用LinkedBlockingQueue。

内部线程池

保持工作线程的集合，线程池需要运行中管理线程的创建、销毁。对带有缓存的线程池，压力较大时会创建新的工作线程，当压力退去，线程池中线程会在一段闲置时间（默认60秒）后结束线程。（newCachedThreadPool）。线程池的工作线程被抽象为静态内部类：Worker，基于AQS实现。

ThreadPoolExecutor:
 
private final HashSet<Worker> workers = new HashSet<Worker>();

任务拒绝处理

任务提交被拒绝，如线程池已经shutdown状态，需要为其提供处理逻辑，如提供的ThreadPoolExecutor.AbortPolicy等默认实现，也可以根据需要自定义。

线程池创建灵活性

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

线程池的几个基本组成部分基本可以从构造函数中体现：

corePoolSize：核心线程数，可以理解为长期驻守的线程数，对于不同的线程池，区别可能比较大。比如newFixedThreadPool会将其设置为nThreads，对于newCachedThreadPool为0.

maximumPoolSize：线程不足时能够创建的最大线程，同样newFixedThreadPool为nThreads，因为其要求是固定大小线程数。而newCachedThreadPool为Integer.MAX_VALUE

keepAliveTime & TimeUnit : 线程能够闲置多久

workQueue：工作队列，必须为BlockingQueue

通过配置不同参数，可以创建出不同的线程池，这就是线程池的灵活性。

线程状态

从上图可以看到ThreadPoolExecutor提供了两个方法来关闭线程池，一个是shutdown() ,一个是shutdownNow()。

Shutdown():不会立即终止线程池，当缓存队列中的任务运行完之后才会终止，而且不会再接收新的任务。

ShutdownNow()：立即终止线程池，并且尝试打断正在运行的线程，清空缓存队列中的任务，返回尚未执行的任务。

线程池工作

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
     
        int c = ctl.get();
//检查工作线程数目，如果小于核心线程数，添加到Worker
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
//检查线程池是否被shutdown了(isRunning)
//工作队列可能是无界也可能是有界，offer入队列
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
//防御检查
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
//尝试一次添加worker，如果失败意味着已经饱和或者shutdown了
        else if (!addWorker(command, false))
            reject(command);
    }

线程池问题

线程池提供了强大和便捷的功能，方便了开发降低了维护成本，但是使用不当也会造成一些问题，强调几点注意。

避免任务堆积

newFixedThreadPool这个创建指定数目线程，任务队列是无界的，如果线程数目设置太小，而处理速度跟不上入队列速度，会造成大量内存堆积导致oom。查疑时可以用jmap之类工具看是否存在大量任务对象入队列的情况。

避免过度扩展线程

一般处理大量短时任务，采用newCachedThreadPool缓存线程池。因为很多情况下，创建线程池的时候，并不知道预计任务压力有多大，很难明确设定一个数目。

避免使用线程池时操作ThreadLocal

      ThreadLocal可以简单理解为key为当前线程的一个Map，它和线程池一起使用的时候会出现问题了，因为线程池为了避免创建过多的线程对象会让线程重用。也就是说有可能会出现ThreadLocal中的线程对象相同的情况。

public class ThreadTest {
 
	static ExecutorService defaultFixedExecutor = Executors.newFixedThreadPool(1);
	static ThreadLocal<String> threadLocal = new ThreadLocal<String>();
 
	public static void main(String[] args) {
		for (int i = 1; i < 4; i++) {
			final int count = i;
			defaultFixedExecutor.submit(new Runnable() {
 
				@Override
				public void run() {
					System.out.println("第"+count+"次循环刚开始，ThreadLocal中的值为："+threadLocal.get());
					threadLocal.set(count+"---");
					System.out.println("第"+count+"次循环结束，ThreadLocal中的值为："+threadLocal.get());
					System.out.println("当前线程名称为："+Thread.currentThread().getName());
					System.out.println("------------------");
				}
			});
		
		}
	}
}

如果真需要使用，请用完后及时清空

public class ThreadTest {

    static ExecutorService defaultFixedExecutor = Executors.newFixedThreadPool(1);
    static ThreadLocal<String> threadLocal = new ThreadLocal<String>();

    public static void main(String[] args) {
        for (int i = 1; i < 4; i++) {
            final int count = i;
            defaultFixedExecutor.submit(new Runnable() {

                @Override
                public void run() {
                    System.out.println("第"+count+"次循环刚开始，ThreadLocal中的值为："+threadLocal.get());
                    threadLocal.set(count+"---");
                    System.out.println("第"+count+"次循环结束，ThreadLocal中的值为："+threadLocal.get());
                    System.out.println("当前线程名称为："+Thread.currentThread().getName());
                    threadLocal.remove();
                    System.out.println("------------------");
                }
            });

        }
    }
}

 

避免死锁

其实线程也好，线程池也好，死锁都会导致系统异常。

一般采用jstack或者类似Jconsole等图形化工具进行定位。

一、jps 或者系统ps命令获取到进程ID

二、调用jstack获取线程棧，分析得到的输出

处于BLOCKED状态的线程，按照试图获取的锁ID查找，能定位到问题。在实际应用中虽然不会这么清晰的输出，但是总体上可以：

区分线程状态 ->查看等待目标->比较Monitor等持有状态，理解线程状态结合程序调用棧结构是能够定位到问题的。

避免线程泄漏

因为逻辑问题，导致工作线程迟迟不会释放。此时可以使用jstack查看下线程棧，可能很多线程都卡在此处了。

线程池大小选择策略

线程池太多太少都会导致一些麻烦问题发生，虽然有时候不能完全确定压力大小，但一些相对规则经验还是必须具备。

1、等待时间较多任务，入I／O操作，可以考虑 Brain Goetz推荐方法获取线程数

线程数 = CPU 核数 * （1 + 平均等待时间 ／ 平均工作时间）

2、线程任务中计算占多，CPU属稀缺资源，通过大量增加线程数提高计算能力往往是不可取的，如果线程太多，可能导致大量上下文切换开销，通常采用CPU核的数目N或N+1