线程池

threadPool

• 示例代码

import java.util.concurrent.*;

public class TestMain {

    //    1、线程池信息： 核心线程数量5，最大数量10，无界队列，超出核心线程数量的线程存活时间：5秒， 无拒绝策略
    // 15个任务，不会使用10个线程去跑，因为等待任务数没有填满队列
    private void test1() throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, new LinkedBlockingQueue());
        testTeak(threadPoolExecutor);
    }

    //    2、线程池信息： 核心线程数量5，最大数量10，队列长度3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
    // 15个任务，最多可以接收13个任务，等待任务数超过队列，会使用最大线程数去运行，然后会有2个任务被拒接
    private void test2() throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue(3), (r, executor) -> System.err.println("mission has been refuse"));
        testTeak(threadPoolExecutor);
    }

    //    3、 线程池信息： 核心线程数量5，最大数量5，无界队列，超出核心线程数量的线程存活时间：0秒
    private void test3() throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        testTeak(threadPoolExecutor);
    }

    //    4.核心线程数量0，最大数量Integer.MAX_VALUE，SynchronousQueue队列，超出核心线程数量的线程存活时间：60秒
    private void test4() throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS, new SynchronousQueue<>());
        testTeak(threadPoolExecutor);
        Thread.sleep(60000L);
        System.out.println("60s later , count number in threadPool: " + threadPoolExecutor.getPoolSize());
    }

    //    5.定时执行线程池信息：3秒后执行，一次性任务，到点就执行
    private void test5() {
        ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
        threadPoolExecutor.schedule(() -> System.out.println("mission have run : " + System.currentTimeMillis()), 3, TimeUnit.SECONDS);
        System.out.println("mission has submit success: " + System.currentTimeMillis());
        System.out.println("count threadPool thread number: " + threadPoolExecutor.getPoolSize());
    }


    // 6.以固定时间作为延迟的计划，间隔时间1秒，如果上次任务大于1秒，则会在完成后立刻触发
    private void test6() {
        ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
        threadPoolExecutor.scheduleAtFixedRate(() -> {
            System.out.println("mission have run : " + System.currentTimeMillis());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 3, 1, TimeUnit.SECONDS);
    }


    // 7.具有固定延迟的计划，间隔时间1秒，但会在完成上次任务3秒的基础上再去延迟1秒
    private void test7() {
        ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5);
        threadPoolExecutor.scheduleWithFixedDelay(() -> {
            System.out.println("mission have run : " + System.currentTimeMillis());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 3, 1, TimeUnit.SECONDS);

    }

    // 8. 终止线程 线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
    private void test8() throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<>(3), (r, executor) -> System.err.println("mission has refuse"));
        for (int i = 0; i < 15; i++) {
            int n = i;
            threadPoolExecutor.submit(() -> {
                try {
                    System.out.println("begin run :" + n);
                    Thread.sleep(3000L);
                    System.err.println("end run :" + n);
                } catch (InterruptedException e) {
                    System.out.println("exception :" + e.getMessage());
                }
            });
            System.out.println("mission has submit success :" + i);
        }

        // 1秒后终止线程池
        Thread.sleep(1000L);
        // 终止线程，会等待所有任务进行完成，但不再接收新任务
        threadPoolExecutor.shutdown();
        // 再次提交提示失败
        threadPoolExecutor.submit(() -> System.out.println("add a new mission"));

    }


    // 8. 终止线程
    private void test9() throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<>(3), (r, executor) -> System.err.println("mission has refuse"));
        for (int i = 0; i < 15; i++) {
            int n = i;
            threadPoolExecutor.submit(() -> {
                try {
                    System.out.println("begin run :" + n);
                    Thread.sleep(3000L);
                    System.err.println("end run :" + n);
                } catch (InterruptedException e) {
                    System.out.println("exception :" + e.getMessage());
                }
            });
            System.out.println("mission has submit success :" + i);
        }

        // 1秒后终止线程池
        Thread.sleep(1000L);
        // 会终止所有进行中的任务，并会抛出InterruptedException异常，并且不再接收新任务
        threadPoolExecutor.shutdownNow();
        // 再次提交提示失败
        threadPoolExecutor.submit(() -> System.out.println("追加一个任务"));

    }


    private void testTeak(ThreadPoolExecutor threadPoolExecutor) throws InterruptedException {
        for (int i = 0; i < 15; i++) {
            int n = i;
            threadPoolExecutor.submit(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "\tbegin run: " + n);
                    Thread.sleep(3000);
                    System.err.println(Thread.currentThread().getName() + "\tend run: " + n);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            System.out.println(Thread.currentThread().getName() + "\tmission submit success : " + n);
        }
        Thread.sleep(500);
        System.out.println("count threadPool now thread number: " + threadPoolExecutor.getPoolSize());
        System.out.println("count threadPool wait thread number: " + threadPoolExecutor.getQueue().size());
        Thread.sleep(15000);
        System.out.println("count threadPool now thread number: " + threadPoolExecutor.getPoolSize());
        System.out.println("count threadPool wait thread number: " + threadPoolExecutor.getQueue().size());
    }


    public static void main(String[] args) throws InterruptedException {

        // 1、线程池信息： 核心线程数量5，最大数量10，无界队列，超出核心线程数量的线程存活时间：5秒， 无拒绝策略
        new TestMain().test1();
        // 2、线程池信息： 核心线程数量5，最大数量10，队列长度3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的
        new TestMain().test2();
        // 线程池信息： 核心线程数量5，最大数量5，无界队列，超出核心线程数量的线程存活时间：0秒
        new TestMain().test3();
        // 核心线程数量0，最大数量Integer.MAX_VALUE，SynchronousQueue队列
        new TestMain().test4();
        // 定时延迟后执行任务
        new TestMain().test5();
        // 以固定时间作为延迟的计划，上次任务完成后，延长动态时长后执行
        new TestMain().test6();
        // 具有固定延迟的计划，上次任务完成后，在延迟固定时长后执行
        new TestMain().test7();
        // 等待任务结束再关闭线程池
        new TestMain().test8();
        // 强制关闭线程池，所有进行中线程都会报异常
        new TestMain().test9();
    }

}