线程池

线程池

线程池 - 如果每一个请求对应一个线程，那么会导致线程大量的创建和销 毁。减少线程的创建和销毁，希望能够重复使用已有的线程，有了线程 池 --- 存储线程的队列

特点:

1. 线程池在创建的时候里面是没有线程的。

2. 当过来请求的时候，就会线程池中创建一个线程来处理这个请求。当

   请求处理完毕的时候，线程就会还回线程池，等待下一个请求。

3. 核心线程在线程池中需要限定数量。

4. 如果所有的核心线程都在使用，那么再来的请求就会放入工作队列

   中。工作队列是一个阻塞式队列。

5. 如果所有的核心线程都被占用并且工作队列已满，那么会创建临时线

   程去处理新的请求。

6. 临时线程处理完请求之后并不是立即销毁，而是存活一段时间，如果

   过了这段时间依然没有新的请求，那么临时线程就被销毁。

创建线程池方式一：使用ThreadPoolExecutor

import java.util.concurrent.*;

public class MyThreadPool {
    public static void main(String[] args) {
        // 执行器服务
        // corePoolSize - 核心线程数量
        // maximumPoolSize - 线程池的容量 = 核心线程数量 + 临时线程数量 // keepAliveTime - 临时线程的存活时间
        // unit - 时间单位
        // workQueue - 工作队列
        // handler - 拒绝执行助手
        ExecutorService es = new ThreadPoolExecutor(5, 10, 300,
                TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(6), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.out.println(new Thread(r).getName() + "线程被拒绝~~~");
            }
        });
        for (int i = 0; i < 18; i++) {
            es.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":hello");
                    try {
                        Thread.sleep(8000);
                    } catch (InterruptedException e) {
                        e.printStackTrace(); }
                }
            });
        }
        es.shutdown();
    }
}

 创建线程池方式二：java提供的Executors

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

public class JavaThreadPool {
    public static void main(String[] args) {
        // 获取缓存线程池
        // 特点:
        // 1. 没有核心线程，所有线程都是临时线程
        // 2. 线程池的容量可以认为是无限的
        // 3. 每一个临时线程存活时间都是1min - 存活时间不长
        // 4. 工作队列是一个同步队列 - 只能存储一个元素
        // 总结:
        // 1. 大池子小队列
        // 2. 理论上能够处理任意多的请求
        // 3. 适合于短任务场景，例如:聊天
        //ExecutorService es = Executors.newCachedThreadPool();
        // 混合线程池
        // 特点:
        // 1. 需要指定核心线程数量
        // 2. 只有核心线程，没有临时线程
        // 3. 工作队列是阻塞式链式队列，没有指定容量 // 总结:
        // 1. 小池子大队列
        // 2. 理论上能够存储任意多的请求
        // 3. 适合于长任务场景，例如:文件下载
        ExecutorService es = Executors.newFixedThreadPool(5);
    }
}

创建线程池方式三：使用guava的ThreadFactoryBuilder() 

package com.nan.si;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.concurrent.*;

@SpringBootTest
class SpringbootApplicationTests {

    @Test
    void contextLoads() {
        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("南思-%d").build();
        ExecutorService es = new ThreadPoolExecutor(5, 5, 60,
                TimeUnit.MICROSECONDS, new ArrayBlockingQueue<Runnable>(10), threadFactory,
                new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 5; i++) {
            es.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":hello");
                }
            });
        }
        es.shutdown();
    }
}

南思-0:hello
南思-1:hello
南思-2:hello
南思-3:hello
南思-4:hello

使用上面的方法创建线程池不仅可以避免OOM的问题，还可以自定义线程名称，更加方便出错时溯源。

总结：

在阿里巴巴java开发手册中明确规定不允许使用Executors创建线程池，因此建议使用方式一或者方式三创建线程池

查看jdk源码

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

可以看到实现是实例化一个ThreadPoolExecutor，创建的阻塞队列为new LinkedBlockQueue。

java中的阻塞队列有两种 ArrayBlockingQueue LinkedBlockingQueue.

ArrayBlockingQueue是一个以数组设计的有界队列，必须设置大小

LinkedBlockingQueue 是一个以链表实现的有界阻塞队列，容量可以选择设置，不设置的话是无界的最大长度为Integer.MAX_VALUE。

所以说Executors创建线程池没有传入阻塞队列的长度，阻塞队列就是一个无边界队列，对于一个无边界队列来说是可以向其中无限添加任务的，这种情况下可能由于任务数太多而导致内存溢出。

FixedThreadPool和SingleThreadPool允许等待的请求队列是Integer.MAX_VALUE 可能导致内存溢出。 而CachedThreadPool和shceduledThreadPool允许创建的线程数量是Integer.MAX_VALUE 同样会出现内存溢出。