创建线程的几种方式

package orange;


import java.util.concurrent.*;

public class MyThread4 {
    public static void main(String[] args) {
        /**
         * 高速缓存的线程池，需要多少创建多少，60s未调用就会自动销毁。
         *                              ThreadPoolExecutor(0, Integer.MAX_VALUE,
         *                                               60L, TimeUnit.SECONDS,
         *                                               new SynchronousQueue<Runnable>())
         */
        ExecutorService executorService = Executors.newCachedThreadPool();

        /**
         *  固定大小的线程池，满了就等待
         *                             ThreadPoolExecutor(nThreads, nThreads,
         *                                               0L, TimeUnit.MILLISECONDS,
         *                                               new LinkedBlockingQueue<Runnable>())
         */
        ExecutorService executorService1 = Executors.newFixedThreadPool(10);

        /**
         * 每次只创建一个线程，满了就等待
         *                              new ThreadPoolExecutor(1, 1,
         *                                             0L, TimeUnit.MILLISECONDS,
         *                                             new LinkedBlockingQueue<Runnable>()))
         */
        ExecutorService executorService2 = Executors.newSingleThreadExecutor();

        /**
         * 自定义线程池
         *         ThreadPoolExecutor(int corePoolSize,    //核心线程数
         *                                       int maximumPoolSize,   //最大线程数
         *                                       long keepAliveTime,    //非核心线程空闲时的存活时间
         *                                       TimeUnit unit,         //存活时间单位
         *                                       BlockingQueue<Runnable> workQueue, //阻塞队列，也就是等着获取线程的
         *                                       ThreadFactory threadFactory,   //线程工厂
         *                                       RejectedExecutionHandler handler)  //拒绝策略,默认为AbortPolicy()
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10,
                20L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());

        executorService.execute(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程执行了");
            }
        });
        executorService1.execute(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程执行了");
            }
        });
        executorService2.execute(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程执行了");
            }
        });

        threadPoolExecutor.execute(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程执行了");
            }
        });
        executorService.shutdown();
        executorService1.shutdown();
        executorService2.shutdown();
        threadPoolExecutor.shutdown();
    }
}