JAVA多线程（线程池、ThreadLocal、CountDownLatch）

目录

1、线程池

了解线程池使用的几种队列（线程池的三种队列区别）

常用的四种创建方法

ThreadPoolExecutor拒绝策略

ThreadPoolExecutor扩展

2、ThreadLocal

3、CountDownLatch计数器

---

1、线程池

池化思想主要是为了避免不停地创建和销毁应用（线程、数据库连接）影响系统性能。

创建线程池实际上还是利用 ThreadPoolExecutor 类实现的

ThreadPoolExecutor(int corePoolSize, 
    int maximumPoolSize, 
    long keepAliveTime, 
    TimeUnit unit, 
    BlockingQueue<Runnable> workQueue, 
    RejectedExecutionHandler handler) 

这几个核心参数的作用：corePoolSize 为线程池的基本大小。maximumPoolSize 为线程池最大线程大小keepAliveTime 和 unit 则是线程空闲后的存活时间。workQueue 用于存放任务的阻塞队列。handler 当队列和最大线程池都满了之后的饱和策略。

了解线程池使用的几种队列

1. SynchronousQueue它没有容量，每一个插入操作都要等待一个相应的删除操作，每一个删除操作都要等待对应的插入操作。以确保,如果没有空闲线程，则尝试创建新的线程；如果线程数量达到最大值，则使用拒绝策略。此方法直接将任务从生产者移交到工作线程，避免任务排队，更高效。
2. ArrayBlockingQueue是一个有界缓存等待队列，可以指定缓存队列的大小，当正在执行的线程数等于corePoolSize时，多余的元素缓存在ArrayBlockingQueue队列中等待有空闲的线程时继续执行，当ArrayBlockingQueue已满时，加入ArrayBlockingQueue失败，会开启新的线程去执行，当线程数已经达到最大的maximumPoolSizes时，再有新的元素尝试加入ArrayBlockingQueue时会报错。
3. LinkedBlockingQueue是一个无界缓存等待队列。当前执行的线程数量达到corePoolSize的数量时，剩余的元素会在阻塞队列里等待。（所以在使用此阻塞队列时maximumPoolSizes就相当于无效了），每个线程完全独立于其他线程。生产者和消费者使用独立的锁来控制数据的同步，即在高并发的情况下可以并行操作队列中的数据。
4. DelayQueue是一个无界阻塞队列，它的队列元素只能在该元素的延迟已经结束或者说过期才能被出队。它怎么判断一个元素的延迟是否结束呢，原来DelayQueue队列元素必须是实现了Delayed接口的实例，该接口有一个getDelay方法需要实现，延迟队列就是通过实时的调用元素的该方法来判断当前元素是否延迟已经结束。DelayQueue底层实现是使用PriorityQueue + ReentrantLock来实现延迟获取功能，它的优先级的值是时间，PriorityQueue的原理是堆排序。

常用的四种创建方法

1. Executors.newSingleThreadExecutor() 创建一个单线程的线程池，保证所有任务按照指定顺序执行（以共享的无界队列方式来运行这些线程，由于是无界队列，有可能造成内存溢出）

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

2. Executors.newFixedThreadPool(int n) 创建一个固定线程数量的线程池（无界）

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

3. Executors.newCachedThreadPool()  线程池数量不确定，有空闲线程则复用，没有就创建新的

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

4. Executors.newScheduledThreadPool(int n) 定长线程池，支持定时及周期性任务执行。scheduleAtFixedRate()方法按周期调度，比如每隔3秒执行一次，若任务执行时间超过3秒，则任务完成后立即进行下一次调度。scheduleWithFixedDelay()方法按延迟间隔周期执行，比如任务完成后间隔3秒进行下一次任务。

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

线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors各个方法的弊端：
1）newFixedThreadPool和newSingleThreadExecutor:
  主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。
2）newCachedThreadPool:
  主要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。 

ThreadPoolExecutor拒绝策略

当队列已经满了，线程池已经是最大数量并且线程都用完了，此时若还有任务进来，需要有拒绝策略。jdk内置了四种拒绝策略：

• 直接抛出异常
• 直接丢弃任务，即不作任何处理
• 使用当前线程（主线程）处理。从线程池到工作队列到应用程序再到TCP层，最终到达客户端，导致服务器在高负载下实现一种平缓的性能降低。
• 抛弃任务队列中最旧的任务也就是最先加入队列的，再把这个新任务添加进去

此外，我们可以通过实现RejectedExecutionHandler接口自定义拒绝策略。

ThreadPoolExecutor扩展

它提供了beforeExecute()、afterExecute()、terminated()等接口方法对线程池进行执行前、执行完成、线程池退出的控制。

强烈推荐：线程池面试题总结

拒绝策略详解

2、ThreadLocal

用来存储线程的本地变量，有一个内部类ThreadLocalMap，每个线程都有自己的ThreadLocalMap，key=ThreadLocal实例本身，value=线程局部变量缓存值

ThreadLocal内存泄露？
ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal没有外部强引用，系统GC时这个ThreadLocal就会被回收，ThreadLocalMap中就出现了key为null的Entry，如果线程不结束，这些Entry的value就会存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value，造成内存泄漏。

ThreadLocalMap针对此做了一些优化，比如在调用ThreadLocal的get()、set()、remove()时都会清理ThreadLocalMap中所有key为null的value。但不能避免内存泄漏的发生，比如分配使用了ThreadLocalMap后不再调用get()、set()、remove()方法。

既然是ThreadLocal的弱引用导致了内存泄漏，那为什么不使用强引用？

使用强引用的话，如果引用ThreadLocal的对象已经回收了，但ThreadLocalMap还持有对ThreadLocal的强引用，导致ThreadLocal不能被回收，会产生更严重的内存泄漏。

避免内存泄漏？

每次使用完ThreadLocal，调用remove()进行清理。

 

ThreadLocalMap

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

引申：InheritableThreadLocal主要用于子线程创建时，需要自动继承父线程的ThreadLocal变量。 

3、CountDownLatch计数器

是一个计数器，等其他线程执行完后再执行，计数器的初始值通过构造函数设置（new CountDownLatch(线程数量)），每当一个线程执行完计数器的值就-1，当计数器的值为0时表示所有线程执行完毕，主线程继续执行。包含三个重要方法：

//调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public void await() throws InterruptedException { };   
//和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
//将count值减1
public void countDown() { };  

CountDownLatch是通过继承AQS（AbstractQueuedSynchronizer）来实现的，AbstractQueuedSynchronizer学习