初探线程池

了解了一下线程池，先记录一下，之后还会更新

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

/**
 * 以下是Java提供的创建线程池的四种常见方式，如果有特殊需求可使用ThreadPoolExecutor创建
 * 
 */
public class MyThreadPoolDemo {
    public static void main(String[] args) {
        /**
         * 第一种方式
         * 线程数目无限制
         * 有空闲线程则复用，否则新建线程
         * 优点：减少线程的创建和销毁，减少系统开销（源码指出，核心线程数目为0，非核心线程闲置60秒销毁），源码：
         * public static ExecutorService newCachedThreadPool() {
         *         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
         *                                       60L, TimeUnit.SECONDS,
         *                                       new SynchronousQueue<Runnable>());
         *     }
         */
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        
        
        
        /**
         * 第二种方式
         *nThreds:线程最大并发数
         * 非核心线程闲置时间为0，
         * 超过了最大并发线程数时会将新的线程放入LinkedBlockingQueue队列等待。源码：
         * public static ExecutorService newFixedThreadPool(int nThreads) {
         *         return new ThreadPoolExecutor(nThreads, nThreads,
         *                                       0L, TimeUnit.MILLISECONDS,
         *                                       new LinkedBlockingQueue<Runnable>());
         *     }
         */
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        
        
        
        
        /**
         * 第三种方式
         * 任务队列是DelayedWorkQueue,支持定时和周期性执行任务，以下是源码
         *public ScheduledThreadPoolExecutor(int corePoolSize) {
         *         super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
         *               new DelayedWorkQueue());
         *     }
         * 
         */
        ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        
        
        
        /**
         * 第四种方式
         * 源码中第一个参数是核心线程的最大数量，第二个参数是总线程的最大数量
         * 第三个是非核心线程闲置时间（时间一到就被销毁），第四个参数是第三个参数的单位
         * 第五个参数是线程的任务队列，当线程数大于时，线程入队等待，该队列没有最大线程数限制，源码：
         * public static ExecutorService newSingleThreadExecutor() {
         *         return new FinalizableDelegatedExecutorService
         *             (new ThreadPoolExecutor(1, 1,
         *                                     0L, TimeUnit.MILLISECONDS,
         *                                     new LinkedBlockingQueue<Runnable>()));
         *     }
         *     public static ExecutorService newSingleThreadExecutor() {
         *         return new FinalizableDelegatedExecutorService
         *             (new ThreadPoolExecutor(1, 1,
         *                                     0L, TimeUnit.MILLISECONDS,
         *                                     new LinkedBlockingQueue<Runnable>()));
         *     }
         */
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        //
        
    }
}

1