Java通过Executors提供四种线程池demo测试 executors四种线程池

Java通过Executors提供四种线程池，分别为：

• newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
• newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
• newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
• newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

相比new Thread，Java提供的四种线程池的好处在于：

• a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
• b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
• c. 提供定时执行、定期执行、单线程、并发数控制等功能。

四种线程池的demo例子

/**
 * @program: test
 * @description: ExecutorService线程池demo
 * @author: 闲走天涯
 * @create: 2021-08-23 17:57
 * Java通过Executors提供四种线程池，分别为：
 * newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
 * newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
 * newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
 * newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
 *
 * 相比new Thread，Java提供的四种线程池的好处在于：
 * a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
 * b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
 * c. 提供定时执行、定期执行、单线程、并发数控制等功能。
 */
public class ExecutorServiceTest {

    /**
     * newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
     */
    public static void newCachedThreadPool(){
        ExecutorService service = Executors.newCachedThreadPool();
        TestRunnable testRunnable = new TestRunnable();
        service.execute(testRunnable);
    }

    /**
     * newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
     */
    public static void newFixedThreadPool(){
        ExecutorService service = Executors.newFixedThreadPool(5);
        TestRunnable testRunnable = new TestRunnable();
        service.execute(testRunnable);
    }

    /**
     * newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
     */
    public static void newScheduledThreadPool(){
//        ExecutorService service = Executors.newScheduledThreadPool(10);
//        TestRunnable testRunnable = new TestRunnable();
//        service.execute(testRunnable);
        //corePoolSize-在池中保持线程的数量，即使它们是空闲的
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        //表示延迟3秒执行
        //service.schedule(new TestRunnable(),3, TimeUnit.SECONDS);
        //表示延迟10秒后每30秒执行一次
        service.scheduleAtFixedRate(new TestRunnable(),10,30, TimeUnit.SECONDS);
    }

    /**
     * newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
     */
    public static void newSingleThreadExecutor(){
        ExecutorService service = Executors.newSingleThreadExecutor();
        TestRunnable testRunnable = new TestRunnable();
        service.execute(testRunnable);
    }

    /**
     * ExecutorService.invokeAny demo
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public static void invokeAny() throws ExecutionException, InterruptedException {
        ExecutorService service = Executors.newSingleThreadExecutor();
        Set<Callable<String>> callables = new HashSet<>();
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "teak 1";
            }
        });
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "teak 2";
            }
        });
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "teak 3";
            }
        });
        //获取任一线程返回值
        String result = service.invokeAny(callables);
        System.out.println("result="+result);
        //关闭线程池
        service.shutdown();
    }

    /**
     * ExecutorService.invokeAll demo
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public static void invokeAll() throws ExecutionException, InterruptedException {
        ExecutorService service = Executors.newSingleThreadExecutor();
        Set<Callable<String>> callables = new HashSet<>();
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "teak 1";
            }
        });
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "teak 2";
            }
        });
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "teak 3";
            }
        });
        //获取所有线程返回值，顺序
        List<Future<String>> result = service.invokeAll(callables);
        for(Future<String> future:result){
            System.out.println("future.get ="+future.get());
        }
        //关闭线程池
        service.shutdown();
    }
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        for (int i = 0; i < 10; i++) {
            //缓存线程池，可灵活回收空闲线程，若无可回收，则新建线程
            //newCachedThreadPool();
            //定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
            //newFixedThreadPool();
            //定长线程池，支持定时及周期性任务执行
            //newScheduledThreadPool();
            //单线程化的线程池，所有任务按照指定顺序执行
            newSingleThreadExecutor();
        }

        //线程返回值，任一线程
        invokeAny();
        //线程返回值，列表所有，顺序
        invokeAll();
    }
}

/**
 * 描述:
 * 实现Runnable接口方式创建多线程
 * @author 闲走天涯
 * @create 2021/3/16 14:45
 * 创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类。
 * 为了实现 Runnable，一个类只需要执行一个方法调用 run()
 */
public class TestRunnable implements Runnable{
    private Integer num=100;

    @Override
    public void run() {
        while (num <= 100) {
            try {
               	Thread.sleep(200);
                num--;
                System.out.println(Thread.currentThread().getName()+"  余票数：" + num);
                if (num <= 0){break;}
            }catch (Exception e){
                System.out.println("异常，退出循环");
                break;
            }
        }
    }
}

ExecutorService的使用

执行方法：

execute(Runnable)：接收一个Runnable实例，并且异步的执行

submit(Runnable)：返回一个Future对象，通过返回的Future对象，我们可以检查提交的任务是否执行完毕

submit(Callable)：也会返回一个Future对象，但是除此之外，submit(Callable)接收的是一个Callable的实现，Callable接口中的call()方法有一个返回值，可以返回任务的执行结果，而Runnable接口中的run()方法是void的，没有返回值。

invokeAny(…) ：方法接收的是一个Callable的集合，执行这个方法不会返回Future，但是会返回所有Callable任务中其中一个任务的执行结果。这个方法也无法保证返回的是哪个任务的执行结果。

invokeAll(…)：接收一个Callable集合，但是前者执行之后会返回一个Future的List，其中对应着每个Callable任务执行后的Future对象。（List 顺序）

shutdown() :不会立即关闭，但是它不再接收新的任务，直到当前所有线程执行完成才会关闭，所有在shutdown()执行之前提交的任务都会被执行。

shutdownNow()：跳过所有正在执行的任务和被提交还没有执行的任务。但是它并不对正在执行的任务做任何保证，有可能它们都会停止，也有可能执行完成。