java.util.concurrent.ExecutorService接口提供了许多线程管理的方法

Method 说明
shutdown 拒绝接收新的任务，待已提交的任务执行后关闭，且宿主线程不阻塞，若需要阻塞可借助awaitTermination实现
shutdownNow 停止所有正在执行的任务，挂起未执行的任务并关闭，且宿主线程不阻塞，若需要阻塞可借助awaitTermination实现
awaitTermination 当发生shutdown时，阻塞宿主线程直到约定的时间已过或者所有任务完成
submit 提交任务Callable/Runnable，可利用Future的get()方法使宿主线程阻塞直到任务结束后返回结果

有了以上方法，便可以基于此接口实现线程池的各种功能(例如java.util.concurrent.ThreadPoolExecutor/java.util.concurrent.ScheduledThreadPoolExecutor)，以java.util.concurrent.ThreadPoolExecutor为例，其参数的详解

Name Type 说明
corePoolSize int 线程池中最小的线程数
maximumPoolSize int 线程池中最大的线程数
keepAliveTime long 线程空闲时间，若线程数大于corePoolSize，空闲时间超过该值的线程将被终止回收
unit TimeUnit keepAliveTime的时间单位
workQueue BlockingQueue<Runnable> 已提交但未执行的任务队列
threadFactory ThreadFactory 创建新线程的工厂
handler RejectedExecutionHandler 当线程池或队列达到上限拒绝新任务抛出异常时的处理类

同时，java.util.concurrent.Executors类提供的常用方法有

Method 说明 基类
newFixedThreadPool 线程池中含固定数量的线程 基于java.util.concurrent.ThreadPoolExecutor类
newSingleThreadExecutor 线程池中仅含一个工作线程
newCachedThreadPool 按需创建线程，若线程池中无可用线程，则创建新的线程并加入，直到线程数达到上限值(Integer.MAX_VALUE)
newWorkStealingPool 按照可用CPU数创建线程池 基于java.util.concurrent.ForkJoinPool类

java.util.concurrent.ForkJoinPool类是Fork/Join框架的实现类，Fork/Join框架是Java7提供了的一个用于并行执行任务的框架， 是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架，该类在有递归实现的场景有更优异的表现。

测试代码如下

import java.util.Date;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import java.util.concurrent.TimeUnit;

import org.junit.Assert;

import org.junit.Test;

/**

 * @Description: 测试ExecutorService

 */

public class ThreadExecutorServiceTest {

    private static final String THIS_IS_SHUTDOWN_WITH_AWAIT_TERMINATION = "This is shutdownWithAwaitTermination";

    private static final int RESULT = 111;

    private static boolean submitRunnable() throws InterruptedException, ExecutionException {

        ExecutorService executorService = Executors.newSingleThreadExecutor();

        Future<?> future = executorService.submit(new Runnable() {

            @Override

            public void run() {

                System.out.println("This is submitRunnable");

            }

        });

        return future.get() == null;

    }

    private static Integer submitRunnableWithResult() throws InterruptedException, ExecutionException {

        ExecutorService executorService = Executors.newSingleThreadExecutor();

        Future<Integer> future = executorService.submit(new Runnable() {

            @Override

            public void run() {

                System.out.println("This is submitRunnableWithResult");

            }

        }, RESULT);

        return future.get();

    }

    private static Integer submitBlockCallable() throws InterruptedException, ExecutionException {

        ExecutorService executorService = Executors.newFixedThreadPool(1);

        Future<Integer> future = executorService.submit(new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                System.out.println("This is submitBlockCallable");

                return RESULT;

            }

        });

        return future.get();// 阻塞

    }

    private static boolean submitNonBlockCallable() throws InterruptedException, ExecutionException {

        ExecutorService executorService = Executors.newFixedThreadPool(1);

        Future<Integer> future = executorService.submit(new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                System.out.println("This is submitNonBlockCallable");

                return RESULT;

            }

        });

        while (!future.isDone()) {// 非阻塞

            System.out.println(new Date());

        }

        return future.isDone();

    }

    private static String shutdown() throws InterruptedException, ExecutionException {

        ExecutorService executorService = Executors.newFixedThreadPool(1);

        final StringBuilder sb = new StringBuilder();

        executorService.submit(new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                Thread.sleep(10000);

                sb.append("This is shutdown");

                return RESULT;

            }

        });

        executorService.shutdown();

        return sb.toString();

    }

    private static String shutdownWithAwaitTermination() throws InterruptedException, ExecutionException {

        ExecutorService executorService = Executors.newFixedThreadPool(1);

        final StringBuilder sb = new StringBuilder();

        executorService.submit(new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                Thread.sleep(10000);

                sb.append(THIS_IS_SHUTDOWN_WITH_AWAIT_TERMINATION);

                return RESULT;

            }

        });

        executorService.shutdown();

        executorService.awaitTermination(Integer.MAX_VALUE, TimeUnit.DAYS);

        return sb.toString();

    }

    @Test

    public void test() throws InterruptedException, ExecutionException {

        Assert.assertTrue(submitRunnable());

        Assert.assertEquals(RESULT, submitRunnableWithResult().intValue());

        Assert.assertEquals(RESULT, submitBlockCallable().intValue());

        Assert.assertTrue(submitNonBlockCallable());

        Assert.assertTrue(shutdown().isEmpty());

        Assert.assertEquals(THIS_IS_SHUTDOWN_WITH_AWAIT_TERMINATION, shutdownWithAwaitTermination());

    }

}

---恢复内容结束---

java.util.concurrent.ExecutorService接口提供了许多线程管理的方法

Method 说明
shutdown 拒绝接收新的任务，待已提交的任务执行后关闭，且宿主线程不阻塞，若需要阻塞可借助awaitTermination实现
shutdownNow 停止所有正在执行的任务，挂起未执行的任务并关闭，且宿主线程不阻塞，若需要阻塞可借助awaitTermination实现
awaitTermination 当发生shutdown时，阻塞宿主线程直到约定的时间已过或者所有任务完成
submit 提交任务Callable/Runnable，可利用Future的get()方法使宿主线程阻塞直到任务结束后返回结果

有了以上方法，便可以基于此接口实现线程池的各种功能(例如java.util.concurrent.ThreadPoolExecutor/java.util.concurrent.ScheduledThreadPoolExecutor)，以java.util.concurrent.ThreadPoolExecutor为例，其参数的详解

Name Type 说明
corePoolSize int 线程池中最小的线程数
maximumPoolSize int 线程池中最大的线程数
keepAliveTime long 线程空闲时间，若线程数大于corePoolSize，空闲时间超过该值的线程将被终止回收
unit TimeUnit keepAliveTime的时间单位
workQueue BlockingQueue<Runnable> 已提交但未执行的任务队列
threadFactory ThreadFactory 创建新线程的工厂
handler RejectedExecutionHandler 当线程池或队列达到上限拒绝新任务抛出异常时的处理类

同时，java.util.concurrent.Executors类提供了基于java.util.concurrent.ThreadPoolExecutor类的工具方法，常用方法有

Method 说明
newFixedThreadPool 线程池中含固定数量的线程
newSingleThreadExecutor 线程池中仅含一个工作线程
newCachedThreadPool 按需创建线程，若线程池中无可用线程，则创建新的线程并加入，直到线程数达到上限值(Integer.MAX_VALUE)

测试代码如下

import java.util.Arrays;

import java.util.Date;

import java.util.List;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.Future;

import java.util.concurrent.TimeUnit;

import org.junit.Assert;

import org.junit.Test;

import org.lxp.multiple.thread.task.SumTask;

/**

 * @Description: 测试ExecutorService

 * @author Super.Li

 * @date Jul 6, 2017

 */

public class ThreadExecutorServiceTest {

    private static final String THIS_IS_SHUTDOWN_WITH_AWAIT_TERMINATION = "This is shutdownWithAwaitTermination";

    private static final int RESULT = 111;

    private static boolean submitRunnable() throws InterruptedException, ExecutionException {

        ExecutorService executorService = Executors.newSingleThreadExecutor();

        Future<?> future = executorService.submit(new Runnable() {

            @Override

            public void run() {

                System.out.println("This is submitRunnable");

            }

        });

        return future.get() == null;

    }

    private static Integer submitRunnableWithResult() throws InterruptedException, ExecutionException {

        ExecutorService executorService = Executors.newSingleThreadExecutor();

        Future<Integer> future = executorService.submit(new Runnable() {

            @Override

            public void run() {

                System.out.println("This is submitRunnableWithResult");

            }

        }, RESULT);

        return future.get();

    }

    private static Integer submitBlockCallable() throws InterruptedException, ExecutionException {

        ExecutorService executorService = Executors.newFixedThreadPool(1);

        Future<Integer> future = executorService.submit(new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                System.out.println("This is submitBlockCallable");

                return RESULT;

            }

        });

        return future.get();// 阻塞

    }

    private static boolean submitNonBlockCallable() throws InterruptedException, ExecutionException {

        ExecutorService executorService = Executors.newFixedThreadPool(1);

        Future<Integer> future = executorService.submit(new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                System.out.println("This is submitNonBlockCallable");

                return RESULT;

            }

        });

        while (!future.isDone()) {// 非阻塞

            System.out.println(new Date());

        }

        return future.isDone();

    }

    private static String shutdown() throws InterruptedException, ExecutionException {

        ExecutorService executorService = Executors.newFixedThreadPool(1);

        final StringBuilder sb = new StringBuilder();

        executorService.submit(new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                Thread.sleep(10000);

                sb.append("This is shutdown");

                return RESULT;

            }

        });

        executorService.shutdown();

        return sb.toString();

    }

    private static String shutdownWithAwaitTermination() throws InterruptedException, ExecutionException {

        ExecutorService executorService = Executors.newFixedThreadPool(1);

        final StringBuilder sb = new StringBuilder();

        executorService.submit(new Callable<Integer>() {

            @Override

            public Integer call() throws Exception {

                Thread.sleep(10000);

                sb.append(THIS_IS_SHUTDOWN_WITH_AWAIT_TERMINATION);

                return RESULT;

            }

        });

        executorService.shutdown();

        executorService.awaitTermination(Integer.MAX_VALUE, TimeUnit.DAYS);

        return sb.toString();

    }

    private static int testForkJoinPool(List<Integer> list) throws InterruptedException, ExecutionException {

        ForkJoinPool forkJoinPool = new ForkJoinPool(8);

        Future<Integer> future = forkJoinPool.submit(new SumTask(list));

        return future.get();

    }

    @Test

    public void test() throws InterruptedException, ExecutionException {

        Assert.assertTrue(submitRunnable());

        Assert.assertEquals(RESULT, submitRunnableWithResult().intValue());

        Assert.assertEquals(RESULT, submitBlockCallable().intValue());

        Assert.assertTrue(submitNonBlockCallable());

        Assert.assertTrue(shutdown().isEmpty());

        Assert.assertEquals(THIS_IS_SHUTDOWN_WITH_AWAIT_TERMINATION, shutdownWithAwaitTermination());

        Assert.assertEquals(10, testForkJoinPool(Arrays.asList(new Integer[] { 1, 2, 3, 4 })));

        Assert.assertEquals(49, testForkJoinPool(Arrays.asList(new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 })));

        Assert.assertEquals(60, testForkJoinPool(Arrays.asList(new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 })));

    }

}

SumTask类如下：

import java.util.List;

import java.util.concurrent.RecursiveTask;

public class SumTask extends RecursiveTask<Integer> {

    private static final long serialVersionUID = 1L;

    private List<Integer> list;

    public SumTask(List<Integer> list) {

        this.list = list;

    }

    /**

     * Ensure it is necessary to divide the job to parts and finish them separately

     *

     * @return

     */

    @Override

    protected Integer compute() {

        int rtn, size = list.size();

        if (size < 10) {

            rtn = sum(list);

        } else {

            SumTask subTask1 = new SumTask(list.subList(0, size / 2));

            SumTask subTask2 = new SumTask(list.subList(size / 2 + 1, size));

            subTask1.fork();

            subTask2.fork();

            rtn = subTask1.join() + subTask2.join();

        }

        return rtn;

    }

    private int sum(List<Integer> list) {

        return list.stream().mapToInt(number -> number.intValue()).sum();

    }

}

Java多线程系列七——ExecutorService的更多相关文章

  1. java多线程系列(七)---Callable、Future和FutureTask

    Callable.Future和FutureTask 前言:如有不正确的地方,还望指正. 目录 认识cpu.核心与线程 java多线程系列(一)之java多线程技能 java多线程系列(二)之对象变量 ...

  2. 【Java多线程系列七】ExecutorService

    java.util.concurrent.ExecutorService接口提供了许多线程管理的方法 Method 说明 shutdown 拒绝接收新的任务,待已提交的任务执行后关闭,且宿主线程不阻塞 ...

  3. （Java多线程系列七）Java内存模型和线程的三大特性

    Java内存模型和线程的三大特性 多线程有三大特性:原子性.可见性.有序性 1.Java内存模型 Java内存模型(Java Memory Model ,JMM),决定一个线程对共享变量的写入时,能对 ...

  4. java多线程系列(八)---CountDownLatch和CyclicBarrie

    CountDownLatch 前言:如有不正确的地方,还望指正. 目录 认识cpu.核心与线程 java多线程系列(一)之java多线程技能 java多线程系列(二)之对象变量的并发访问 java多线 ...

  5. java多线程系列(九)---ArrayBlockingQueue源码分析

    java多线程系列(九)---ArrayBlockingQueue源码分析 目录 认识cpu.核心与线程 java多线程系列(一)之java多线程技能 java多线程系列(二)之对象变量的并发访问 j ...

  6. Java多线程系列--“JUC线程池”06之 Callable和Future

    概要 本章介绍线程池中的Callable和Future.Callable 和 Future 简介示例和源码分析(基于JDK1.7.0_40) 转载请注明出处:http://www.cnblogs.co ...

  7. Java多线程系列--“JUC锁”11之 Semaphore信号量的原理和示例

    概要 本章,我们对JUC包中的信号量Semaphore进行学习.内容包括:Semaphore简介Semaphore数据结构Semaphore源码分析(基于JDK1.7.0_40)Semaphore示例 ...

  8. Java多线程系列--“JUC线程池”01之 线程池架构

    概要 前面分别介绍了"Java多线程基础"."JUC原子类"和"JUC锁".本章介绍JUC的最后一部分的内容——线程池.内容包括:线程池架构 ...

  9. Java多线程系列--“JUC线程池”03之 线程池原理(二)

    概要 在前面一章"Java多线程系列--“JUC线程池”02之 线程池原理(一)"中介绍了线程池的数据结构,本章会通过分析线程池的源码,对线程池进行说明.内容包括:线程池示例参考代 ...

随机推荐

  1. K/3Cloud 分页报表示例参考

    分页报表首先需要实现的方法就是GetList,这个方法用来获得分页的条件. 其他的就和其他报表类似了. using System; using System.Collections.Generic; ...

  2. POJ 3620 Avoid The Lakes

    http://poj.org/problem?id=3620 DFS 从任意一个lake出发 重置联通的lake 并且记录 更新ans #include <iostream> #inclu ...

  3. 谈谈APP架构选型：React Native还是HBuilder

    原文链接 导读:最近公司的一款新产品APP要进行研发,老大的意思想用H5来做混合APP以达到高效敏捷开发的目的.我自然就开始进行各种技术选型的调研,这里重点想说的是我最后挑选出的2款hybrid ap ...

  4. noip 2015 day1

    T1 神奇的幻方 题目描述 幻方是一种很神奇的N*N矩阵:它由数字1,2,3,……,N*N构成,且每行.每列及两条对角线上的数字之和都相同. 当N为奇数时,我们可以通过以下方法构建一个幻方: 首先将1 ...

  5. codevs——2822 爱在心中

    2822 爱在心中  时间限制: 1 s  空间限制: 128000 KB  题目等级 : 钻石 Diamond 题解       题目描述 Description “每个人都拥有一个梦,即使彼此不相 ...

  6. IDEA下使用protobuf2(java)

    目录 一.介绍 二.特点 三.结构 四.选择版本 五.Intellij IDEA中使用Protobuf 1.下载个protoc.exe 2.编辑个.proto文件 3.将.proto文件转成Java类 ...

  7. Spring @Value用法

    Spring 通过注解获取*.porperties文件的内容,除了xml配置外,还可以通过@value方式来获取. 使用方式必须在当前类使用@Component,xml文件内配置的是通过pakage扫 ...

  8. 一处折腾笔记：Android内嵌html5加入原生微信分享的解决的方法

    有一段时间没有瞎折腾了. 这周一刚上班萌主过来反映说:微信里面打开聚客宝.分享功能是能够的(这里是用微信自身的js-sdk实现的).可是在android应用里面打开点击就没反应了:接下来狡猾的丁丁在产 ...

  9. 怎样更好的设计你的REST API之基于REST架构的Web Service设计及REST框架实现

    一.REST 含状态传输(英文:Representational State Transfer,简称REST)是Roy Fielding博士在2000年他的博士论文中提出来的一种软件架构风格. 眼下在 ...

  10. 使用literal语法格式化字符串

    支持arm64之后,格式化字符串的时候会遇到一些问题,主要与NSInteger的定义有关: #if __LP64__ || (TARGET_OS_EMBEDDED && !TARGET ...