Java多线程之ExecutorService使用说明

一、简介

ExecutorService是Java中对线程池定义的一个接口，它java.util.concurrent包中，在这个接口中定义了和后台任务执行相关的方法。

二、线程池

Java给我们提供了一个Executors工厂类，它可以帮助我们很方便的创建各种类型ExecutorService线程池，Executors一共可以创建下面这四类线程池：

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

三、代码举例

import org.junit.Test;
import java.util.concurrent.*;

/**
 * @author ：gongxr
 * @description：ExecutorService是Java中对线程池定义的一个接口，它java.util.concurrent包中，在这个接口中定义了和后台任务执行相关的方法。 Java通过Executors提供四种创建线程池的工厂类，分别为：
 * newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
 * newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
 * newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
 * newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
 */

public class TestExecutorService {
    /**
     * newCachedThreadPool:创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
     */
    @Test
    public void test1() throws InterruptedException {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName() + " 开始工作！");
                    Thread.sleep((long) (Math.random() * 3000));
                    System.out.println(Thread.currentThread().getName() + " 工作结束！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 5; i++) {
            cachedThreadPool.execute(runnable);
        }
        Thread.sleep(3000);
        System.out.println("主线程结束！");
        cachedThreadPool.shutdown();
    }

    /**
     * newFixedThreadPool:创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
     */
    @Test
    public void test2() throws InterruptedException {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName() + " 开始工作！");
                    Thread.sleep((long) (Math.random() * 3000));
                    System.out.println(Thread.currentThread().getName() + " 工作结束！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 0; i < 6; i++) {
            final int index = i;
            fixedThreadPool.execute(runnable);
        }
        Thread.sleep(6000);
        fixedThreadPool.shutdown();
        System.out.println("主线程结束！");
    }

    /**
     * newScheduledThreadPool:创建一个定长线程池，支持定时及周期性任务执行。
     * 该例中延迟3秒执行。
     */
    @Test
    public void test3_1() throws InterruptedException {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("delay 3 seconds");
            }
        };
        scheduledThreadPool.schedule(runnable, 3, TimeUnit.SECONDS);
        Thread.sleep(10000);
        scheduledThreadPool.shutdown();
    }

    /**
     * newScheduledThreadPool:创建一个定长线程池，支持定时及周期性任务执行。
     * 延迟1秒后每3秒执行一次。
     */
    @Test
    public void test3_2() throws InterruptedException {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("delay 1 seconds, and excute every 3 seconds");
            }
        };
        scheduledThreadPool.scheduleAtFixedRate(runnable, 1, 3, TimeUnit.SECONDS);
        Thread.sleep(10000);
        scheduledThreadPool.shutdown();
    }

    /**
     * newSingleThreadExecutor:创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
     */
    @Test
    public void test4() throws InterruptedException {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(index);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        Thread.sleep(10000);
        singleThreadExecutor.shutdown();
    }

    /**
     * submit(Callable)
     * submit(Callable)和submit(Runnable)类似，也会返回一个Future对象，
     * 但是除此之外，submit(Callable)接收的是一个Callable的实现，
     * Callable接口中的call()方法有一个返回值，可以返回任务的执行结果，
     * 而Runnable接口中的run()方法是void的，没有返回值。
     */
    @Test
    public void testCallable() throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Callable callable = new Callable() {
            @Override
            public Object call() throws InterruptedException {
                String name = Thread.currentThread().getName();
                System.out.println("Thread Name:" + name + " 开始工作！");
                Thread.sleep((long) (Math.random() * 3000));
                System.out.println("Thread Name:" + name + " 结束工作！");
                return name;
            }
        };

        Future future = executorService.submit(callable);

        System.out.println("主线程继续执行！");
        Thread.sleep(3000);

        // future.get()使得主线程阻塞，等待子线程执行结束
        System.out.println("子线程执行完回调结果:" + future.get().toString());

        System.out.println("主线程结束！");
        executorService.shutdown();
    }

    /**
     * ExecutorService的shutdown、shutdownNow、awaitTermination用法：
     * 调用shutdown方法之后，ExecutorService不再接收新的任务，直到当前所有线程执行完成才会关闭，所有之前提交的任务都会被执行。
     * 调用shutdownNow方法后，将试图阻止所有正在执行的任务和被提交还没有执行的任务。
     * awaitTermination方法的作用：监视各任务的状态是否已经结束，经过指定的时间后，全部完成返回true，反之返回false。
     */
    @Test
    public void testShutDown() throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName() + " 开始工作！");
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName() + " 工作结束！");
                } catch (InterruptedException e) {
                    System.out.println(Thread.currentThread().getName() + " 子线程中断！");
                    e.printStackTrace();
                }
            }
        };
        // 线程1
        executorService.execute(runnable);
        Thread.sleep(1000);
        // 线程2
        executorService.execute(runnable);
        executorService.shutdown();
        // 等待一秒后检查子线程运行状态，全部完成返回true
        if (!executorService.awaitTermination(1, TimeUnit.SECONDS)) {
            System.out.println("主线程强制中断子线程！");
            executorService.shutdownNow();
        }
        Thread.sleep(4000);
        System.out.println("主线程结束！");
    }

}

与多线程同步工具结合使用：

    /**
     * ExecutorService实战用法：
     * 与CountDownLatch线程同步工具结合使用
     */
    @Test
    public void testExe() throws Exception {
        int count = 5; // 任务数量
        ExecutorService executorService = Executors.newCachedThreadPool();
        CountDownLatch countDownLatch = new CountDownLatch(count);  //线程同步工具

        for (int i = 1; i <= count; i++) {
            int taskId = i;
            executorService.execute(() -> task(taskId, countDownLatch));
        }

        executorService.shutdown();  // 不再接受新任务
        countDownLatch.await();  // 等待所有任务完成
        // 等待一秒后检查子线程运行状态，全部完成返回true
        if (!executorService.awaitTermination(1, TimeUnit.SECONDS)) {
            System.out.println("主线程强制中断子线程！");
            executorService.shutdownNow();
        }
        System.out.println("主线程结束！");
    }

    private void task(int index, CountDownLatch countDownLatch) {
        try {
            System.out.println("任务" + index);
            System.out.println(Thread.currentThread().getName() + " 开始工作！");
            Thread.sleep((long) (Math.random() * 3000));
            System.out.println(Thread.currentThread().getName() + " 工作结束！");
            countDownLatch.countDown();
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName() + " 子线程中断！");
            e.printStackTrace();
        }
    }

 运行结果：

任务1
任务3
任务4
pool-1-thread-4 开始工作！
任务2
pool-1-thread-2 开始工作！
任务5
pool-1-thread-3 开始工作！
pool-1-thread-1 开始工作！
pool-1-thread-5 开始工作！
pool-1-thread-3 工作结束！
pool-1-thread-2 工作结束！
pool-1-thread-5 工作结束！
pool-1-thread-4 工作结束！
pool-1-thread-1 工作结束！
主线程结束！