JDK线程池实践

JDK线程池，网上很多代码和示例，自己就实践一下，看看运行结果，加深理解。

public class Test {

    public static int getCoreSize() {
        int core = Runtime.getRuntime().availableProcessors();
        System.out.println("core : " + core);
        return core;
    }

    /**
     * SinglePool。
     * 预期结果：顺序执行
     * @throws InterruptedException 
     */
    public static void singlePool() throws InterruptedException {
        ExecutorService es = Executors.newSingleThreadExecutor();

        Runnable r1 =  SimpleRunnable.getInstance(5);
        Runnable r2 =  SimpleRunnable.getInstance(4);
        Runnable r3 =  SimpleRunnable.getInstance(3);
        Runnable r4 =  SimpleRunnable.getInstance(2);
        Runnable r5 =  SimpleRunnable.getInstance(1);

        es.submit(r1);
        es.submit(r2);
        es.submit(r3);
        es.submit(r4);
        es.submit(r5);

        Thread.sleep(1000l);

        es.shutdown();
    }

    /**
     * 线程不会终止，SinglePool。
     * 预期结果：1个线程运行
     * @throws InterruptedException 
     */
    public static void endlessSinglePool() throws InterruptedException {
        ExecutorService es = Executors.newSingleThreadExecutor();
        Runnable r1 =  EndlessRunnable.getInstance();
        Runnable r2 =  EndlessRunnable.getInstance();
        Runnable r3 =  EndlessRunnable.getInstance();
        Runnable r4 =  EndlessRunnable.getInstance();
        Runnable r5 =  EndlessRunnable.getInstance();

        es.submit(r1);
        es.submit(r2);
        es.submit(r3);
        es.submit(r4);
        es.submit(r5);

        Thread.sleep(1000l);
    }

    /**
     * 线程不会终止，CachedPool。
     * 预期结果：随机执行，所有线程执行
     * @throws InterruptedException 
     */
    public static void endlessCachedPool() throws InterruptedException {
        ExecutorService es = Executors.newCachedThreadPool();

        Runnable r1 =  EndlessRunnable.getInstance();
        Runnable r2 =  EndlessRunnable.getInstance();
        Runnable r3 =  EndlessRunnable.getInstance();
        Runnable r4 =  EndlessRunnable.getInstance();
        Runnable r5 =  EndlessRunnable.getInstance();

        es.submit(r1);
        es.submit(r2);
        es.submit(r3);
        es.submit(r4);
        es.submit(r5);

        Thread.sleep(1000l);

        // 结果：程序并不会终止，无任何信息执行。意味着shutdown无用。
        // 代码分析： interruptIdleWorkers();终止空闲线程。通过thread.interrupt()。
        // es.shutdown();

        // 结果：程序并不会终止，报sleep被中断异常。shutdownNow会试图终止掉阻塞的线程，但因为while循环，并不会杀死线程。
        // 代码分析： interruptWorkers();终止工作线程。通过thread.interrupt()。
        //es.shutdownNow();


    }

    /**
     * 线程不会终止，FixedPool。
     * 预期结果：3个线程运行
     * @throws InterruptedException 
     */
    public static void endlessFixedPool() throws InterruptedException {
        ExecutorService es = Executors.newFixedThreadPool(3);
        Runnable r1 =  EndlessRunnable.getInstance();
        Runnable r2 =  EndlessRunnable.getInstance();
        Runnable r3 =  EndlessRunnable.getInstance();
        Runnable r4 =  EndlessRunnable.getInstance();
        Runnable r5 =  EndlessRunnable.getInstance();

        es.submit(r1);
        es.submit(r2);
        es.submit(r3);
        es.submit(r4);
        es.submit(r5);

        Thread.sleep(1000l);
    }

    /**
     * 前置条件：core:2, max:4, queue:2。EndlessRunanble。
     * 预期结果：加入2个任务，2个线程运行。加入4个线程，2个线程运行。
     *              加入6个线程，4个线程运行，且运行的是1，2，5，6。加入8个线程，报拒绝异常。
     * 关于线程生成策略思考：小于core，每个任务都新建线程：哥有的是线程资源，随便用，不用等；
     *                    大于core小于core+queueSize，排队不生成新线程：虽然任务有点多，但还是可以负担得起。不增加新线程，节约开销；
     *                    大于core+queueSize小于max，创建新线程处理新任务，旧的排队线程依然排队（不讲先来后到）：扛不住了，找外援；
     *                    大于max，根据策略处理新加的任务，默认拒绝：我处理不了了，拒绝新任务。
     * @throws InterruptedException 
     */
    public static void threadPool() throws InterruptedException {
        ExecutorService es = new ThreadPoolExecutor(2, 4, 1000, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2));

        EndlessRunnableWithState r1 = EndlessRunnableWithState.getInstance(1);
        EndlessRunnableWithState r2 = EndlessRunnableWithState.getInstance(2);
        EndlessRunnableWithState r3 = EndlessRunnableWithState.getInstance(3);
        EndlessRunnableWithState r4 = EndlessRunnableWithState.getInstance(4);
        EndlessRunnableWithState r5 = EndlessRunnableWithState.getInstance(5);
        EndlessRunnableWithState r6 = EndlessRunnableWithState.getInstance(6);
        EndlessRunnableWithState r7 = EndlessRunnableWithState.getInstance(7);
        EndlessRunnableWithState r8 = EndlessRunnableWithState.getInstance(8);


        es.submit(r1);
        es.submit(r2);

        Thread.sleep(3000l);
        System.out.println("sleep 1 over.");

        es.submit(r3);
        es.submit(r4);

        Thread.sleep(3000l);
        System.out.println("sleep 2 over.");

        es.submit(r5);
        es.submit(r6);

        Thread.sleep(3000l);
        System.out.println("sleep 3 over.");
        es.submit(r7);
        es.submit(r8);

    }

    /**
     * 预期结果：4个线程执行同一个任务。
     * 结果分析：每次commit，将任务包装为RunnableFuture对象，然后进行后续操作。不会判断任务是否已存在。同一个任务多个线程执行，得注意线程安全。
     * @throws InterruptedException
     */
    public static void taskRunMultiTime() throws InterruptedException {
        ExecutorService es = Executors.newFixedThreadPool(4);

        EndlessRunnableWithState r1 = EndlessRunnableWithState.getInstance(1);

        es.submit(r1);
        es.submit(r1);
        es.submit(r1);
        es.submit(r1);

        Thread.sleep(3000l);
    }

    public static void main(String[] args) throws InterruptedException {        
        //singlePool();
        //endlessSinglePool();
        //endlessCachedPool();
        //endlessFixedPool();
        //  threadPool();

        taskRunMultiTime();
    }

}

public class SimpleRunnable implements Runnable {

    private int count;

    private SimpleRunnable(int count) {
        this.count = count;
    }

    public static SimpleRunnable getInstance(int count) {
        return new SimpleRunnable(count);
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " running ... with count : " + count);

    }

}

public class EndlessRunnable implements Runnable {

    public static EndlessRunnable getInstance() {
        return new EndlessRunnable();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " running ...");
        while (true) {
            try {
                Thread.sleep(10000l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

public class EndlessRunnableWithState implements Runnable {

    private int count;

    private EndlessRunnableWithState(int count) {
        this.count = count;
    }

    public static EndlessRunnableWithState getInstance(int count) {
        return new EndlessRunnableWithState(count);
    }

    @Override
    public void run() {
        System.out.println("thread " + count + " running ...");
        while (true) {
            try {
                Thread.sleep(10000l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}