202108101240 - 常见的6种线程池

除了ForkJoinPool()，都使用了Executors.defaultThreadFactory()，本质还是new Thread()来创建线程。

都是juc.Executors中，new ThreadPoolExecutor() ;

int corePoolSize = 5;  
int maximumPoolSize = 5;  
int keepAliveTime = 0;  
TimeUnit unit = TimeUnit.MILLISECONDS;  
LinkedBlockingQueue workQueue = new LinkedBlockingQueue(20);  
RejectedExecutionHandler defaultHandler = new ThreadPoolExecutor.AbortPolicy();  
ExecutorService service = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,  
 Executors.defaultThreadFactory(), defaultHandler);

Executors.newFixedThreadPool(5);

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

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

任务执行完后，不会自动销毁

newCachedThreadPool()

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

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

Creates a {@code SynchronousQueue} with nonfair access policy.
public SynchronousQueue() {  
    this(false);  
}

执行完后，60秒内无新任务的线程会被销毁

newSingleThreadExecutor()

/**  
 * Creates an Executor that uses a single worker thread operating * off an unbounded queue. (Note however that if this single * thread terminates due to a failure during execution prior to * shutdown, a new one will take its place if needed to execute * subsequent tasks.)  Tasks are guaranteed to execute * sequentially, and no more than one task will be active at any * given time. Unlike the otherwise equivalent * {@code newFixedThreadPool(1)} the returned executor is  
 * guaranteed not to be reconfigurable to use additional threads. * * @return the newly created single-threaded Executor  
 */
 public static ExecutorService newSingleThreadExecutor() {  
    return new FinalizableDelegatedExecutorService  
        (new ThreadPoolExecutor(1, 1,  
 0L, TimeUnit.MILLISECONDS,  
 new LinkedBlockingQueue<Runnable>()));  
}

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

newScheduledTheadPool()

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {  
    return new ScheduledThreadPoolExecutor(corePoolSize);  
}

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

newSingleThreadScheduledExecutor

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {  
    return new DelegatedScheduledExecutorService  
        (new ScheduledThreadPoolExecutor(1));  
}

ForkJoinPool

public ForkJoinPool() {  
    this(Math.min(MAX_CAP, Runtime.getRuntime().availableProcessors()),  
 defaultForkJoinWorkerThreadFactory, null, false);  
}

每个子线程维护一个子队列，dequeue