线程池

并发与并行

• 并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时
• 并发：通过cpu算法，让用户看上去同时执行，实际上cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公共的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。
• 线程安全：经常用来描绘一段代码，指在并发的情况下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cpu是不是够用即可。线程不安全则意味着线程的调度顺序会影响最终结果。
• 同步：java中的同步指的是通过人为的控制和调度，保证共享资源的多线程访问成为线程安全，来保证结果的准确。Threadlocal类：保存线程的独立变量。对于一个线程池，当使用Threadlocal维护变量时，Threadlocal会为每个使用该变量的线程提供独立的变量副本,而不会影响其他线程所对应的副本

---

线程池的各个参数的含义

public interface Executor {
    void execute(Runnable command);
}

package java.util.concurrent;
import java.util.List;
import java.util.Collection;
public interface ExecutorService extends Executor {

    void shutdown();

    List<Runnable> shutdownNow();

    boolean isShutdown();

    boolean isTerminated();

    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

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

    <T> Future<T> submit(Runnable task, T result);

    Future<?> submit(Runnable task);

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                              long timeout, TimeUnit unit)
        throws InterruptedException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Executors工具方法，用来创建线程池

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

创建的线程池的底层实际都是ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)
						  
corePoolSize:核心线程数，就算空闲状态也会保持该线程数
maximumPoolSize：最大线程数
keepAliveTime：空闲线程的存活时间，如果某线程的空闲时间超过这个值都没有任务给它做，那么就可以被关闭了。注意这个值并不会对所有的线程起作用，当线程池中的线程数少于等于corePoolSize，那么这些线程就不会因为空闲太久而被关闭
unit：时间单位
workQueue：任务队列
threadFactory：线程工厂类，有默认实现
RejectedExecutionHandler：线程池拒绝策略

拒绝策略包括：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。（默认采用）
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

线程的创建时机

1. 如果当前线程数少于corePoolSize，那么提交任务的时候创建一个新的线程，并由这个线程执行这个任务
2. 如果当前线程数已经达到corePoolSize，那么提交的任务添加到任务队列，等待线程池中的线程去队列中取任务
3. 如果队列已满，那么创建新的线程来执行任务，需要保证池中的线程数不会超过maximumPoolSize，如果此时线程数超过了maximumPoolSize，那么执行拒绝策略

---

强制

线程池不允许使用 Executors 去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
说明:Executors 返回的线程池对象的弊端如下:

1. FixedThreadPool 和 SingleThreadPool:
   • 允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
2. CachedThreadPool 和 ScheduledThreadPool:
   • 允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM