线程池实践小记

一、ThreadPoolExecutor

ThreadPoolExecutor 是JDK自带的线程池。

主要使用的构造方法：

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

corePoolSize：线程核心参数
maximumPoolSize：最大线程数
keepAliveTime：非核心闲置线程存活时间
unit：时间的单位，时/分/秒之类
workQueue：线程池等待队列
handler：如果线程池等待队列满了，而且正在运行的线程数量大于maximumPoolSize，线程池执行的拒绝策略

二、实践

	public static void main(String[] args) throws InterruptedException {
		ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 3, 0, TimeUnit.MILLISECONDS,
				new LinkedBlockingDeque<>(2), new ThreadPoolExecutor.CallerRunsPolicy());

		Thread t1 = new Thread(()-> {
            System.out.println("第一个线程开始！" + Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executor.execute(t1);
        Thread.sleep(100);

        Thread t2 = new Thread(()-> {
            System.out.println("第二个线程开始！" + Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executor.execute(t2);
        Thread.sleep(100);

        Thread t3 = new Thread(()-> {
            System.out.println("第三个线程开始！" + Thread.currentThread().getName());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executor.execute(t3);
        Thread.sleep(100);

        Thread t4 = new Thread(()-> {
            System.out.println("第四个线程开始！" + Thread.currentThread().getName());
            try {
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executor.execute(t4);
        Thread.sleep(100);

        Thread t5 = new Thread(()-> {
            System.out.println("第五个线程开始！" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executor.execute(t5);
        Thread.sleep(100);

        Thread t6 = new Thread(()-> {
            System.out.println("第六个线程开始！" + Thread.currentThread().getName());
        });
        executor.execute(t6);
        Thread.sleep(100);

        Thread t7 = new Thread(()-> {
            System.out.println("第七个线程开始！" + Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        executor.execute(t7);
        Thread.sleep(100);

        Thread t8 = new Thread(()-> {
            System.out.println("第八个线程开始！" + Thread.currentThread().getName());
        });
        executor.execute(t8);

	}

执行结果：

第一个线程开始！pool-1-thread-1
第四个线程开始！pool-1-thread-2
第五个线程开始！pool-1-thread-3
第六个线程开始！main
第七个线程开始！main
第二个线程开始！pool-1-thread-3
第三个线程开始！pool-1-thread-2
第八个线程开始！pool-1-thread-1