线程池探索

package com.kelvin.util;

import org.springframework.util.StopWatch;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author Kelvin范显
 * @createDate 2018年01月11日
 */
public class MyTest {
    public static void main(String[] args) throws Exception {
        // 核心线程个数，最大线程个数，均为3.
        // 每个线程只能空闲0.1秒
        // 有定长为1的等待队列， 可以有一个线程排队
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 3,
                100, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(1), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.out.println("线程池耗尽，拒绝访问:" + Thread.currentThread().getName());
            }
        });
        pool.allowsCoreThreadTimeOut();

        class SelfUtil{
            void printPoolSize(){
                System.out.println("当前存活线程数："+pool.getActiveCount());
            }

            /**
             * 每1秒打印线程数， 共打印n次
             * @param n
             */
            void printPoolSizePer1second(long n){
                System.out.println("-----主线程开始等待--------");
                for (int i = 0; i <n ; i++) {
                    doOncePerSecond(()->printPoolSize());
                }
                System.out.println("-----主线程等待了"+n+"秒--------");
            }
        }
        SelfUtil t = new SelfUtil();

        t.printPoolSize();
        multiAccess("第一次",pool);
        t.printPoolSizePer1second(5);

        t.printPoolSize();
        multiAccess("第二次",pool);
        t.printPoolSizePer1second(5);

        t.printPoolSize();
        multiAccess("第三次",pool);
        t.printPoolSizePer1second(5);
    }

    /**
     * 提交4个任务，每个任务执行2秒
     * @param name
     * @param pool
     */
    private static void multiAccess(String name,ThreadPoolExecutor pool) {
        System.out.println("===============================================");
        System.out.println(name+"并发访问");
        for (int i = 0; i < 4; i++) {
            pool.execute(()->{
                try {
                    StopWatch stopWatch = new StopWatch();
                    stopWatch.start();
                    Thread.sleep(2000);
                    stopWatch.stop();
                    System.out.println(Thread.currentThread().getName()+"执行完成，花费了"+stopWatch.getTotalTimeSeconds()+"秒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }

    /**
     * 每隔1秒做一次
     * @param runnable
     */
    private static void doOncePerSecond(Runnable runnable){
        try {
            Thread.currentThread().sleep(1000);
            runnable.run();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

当前存活线程数：0
===============================================
第一次并发访问
-----主线程开始等待--------
当前存活线程数：3
当前存活线程数：3
pool-1-thread-3执行完成，花费了2.0秒
pool-1-thread-1执行完成，花费了2.0秒
pool-1-thread-2执行完成，花费了2.0秒
当前存活线程数：1
当前存活线程数：1
pool-1-thread-3执行完成，花费了2.0秒
当前存活线程数：0
-----主线程等待了5秒--------
当前存活线程数：0
===============================================
第二次并发访问
线程池耗尽，拒绝访问:main
线程池耗尽，拒绝访问:main
-----主线程开始等待--------
当前存活线程数：2
pool-1-thread-1执行完成，花费了2.0秒
pool-1-thread-2执行完成，花费了2.0秒
当前存活线程数：1
当前存活线程数：0
当前存活线程数：0
当前存活线程数：0
-----主线程等待了5秒--------
当前存活线程数：0
===============================================
第三次并发访问
线程池耗尽，拒绝访问:main
线程池耗尽，拒绝访问:main
-----主线程开始等待--------
当前存活线程数：2
当前存活线程数：2
pool-1-thread-1执行完成，花费了2.001秒
pool-1-thread-3执行完成，花费了2.001秒
当前存活线程数：0
当前存活线程数：0
当前存活线程数：0
-----主线程等待了5秒--------