ExecutorService、Callable、Future

最新推荐文章于 2024-08-21 16:47:09 发布
最新推荐文章于 2024-08-21 16:47:09 发布
阅读量602 收藏
点赞数
分类专栏： java多线程 文章标签： ExecutorService Callable Future
    在Java中，如果需要设定代码执行的最长时间，即超时，可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分，在java.util.concurrent包中。Future接口是Java线程Future模式的实现，可以来进行异步计算。
    
    Future模式可以这样来描述：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那儿取出结果。就相当于下了一张订货单，一段时间后可以拿着提订单来提货，这期间可以干别的任何事情。其中Future 接口就是订货单，真正处理订单的是Executor类，它根据Future接口的要求来生产产品。

    Future接口提供方法来检测任务是否被执行完，等待任务执行完获得结果，也可以设置任务执行的超时时间。这个设置超时的方法就是实现Java程序执行超时的关键。

    Future接口是一个泛型接口，严格的格式应该是Future<V>，其中V代表了Future执行的任务返回值的类型。 Future<V>代表一个异步执行的操作，通过get()方法可以获得操作的结果，如果异步操作还没有完成，则，get()会使当前线程阻塞。FutureTask<V>实现了Future<V>和Runable<V>。Callable代表一个有返回值得操作。

    Executors类，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。
    public static ExecutorService newFixedThreadPool(int nThreads)
    创建固定数目线程的线程池。
    public static ExecutorService newCachedThreadPool()
    创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
    public static ExecutorService newSingleThreadExecutor()
    创建一个单线程化的Executor。
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
    创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。
    
    下面看3个小例子：
    例1：
     
package com.paincupid.springmvc;

import java.util.concurrent.*;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings("unchecked")
public class Test {
	public static void main(String[] args) throws ExecutionException,
			InterruptedException {
		System.out.println("----程序开始运行----");
		Date date1 = new Date();
		int taskSize = 5;
		// 创建一个线程池
		ExecutorService pool = Executors.newFixedThreadPool(taskSize);
		// 创建多个有返回值的任务
		List<Future> list = new ArrayList<Future>();
		for (int i = 0; i < taskSize; i++) {
			Callable c = new MyCallable(i + " ");
			// 执行任务并获取Future对象
			Future f = pool.submit(c);
			list.add(f);
		}
		// 关闭线程池
		pool.shutdown();

		// 获取所有并发任务的运行结果
		for (Future f : list) {
			// 从Future对象上获取任务的返回值，并输出到控制台
			System.out.println(">>>" + f.get().toString());
		}

		Date date2 = new Date();
		System.out.println("----程序结束运行----，程序运行时间【"
				+ (date2.getTime() - date1.getTime()) + "毫秒】");
	}
}

class MyCallable implements Callable {
	private String taskNum;

	MyCallable(String taskNum) {
		this.taskNum = taskNum;
	}

	public Object call() throws Exception {
		System.out.println(">>>" + taskNum + "任务启动");
		Date dateTmp1 = new Date();
		Thread.sleep(1000);
		Date dateTmp2 = new Date();
		long time = dateTmp2.getTime() - dateTmp1.getTime();
		System.out.println(">>>" + taskNum + "任务终止");
		return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
	}
}


    例2：
     
package com.paincupid.springmvc;

import java.util.ArrayList;  
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.Future;  
import java.util.concurrent.FutureTask;  
 /**
  * 
  * @author paincupid
  *	 本例原文，推荐地址：http://www.iteye.com/topic/366591
  */
public class ConcurrentCalculator {  
  
    private ExecutorService exec;  
    private int cpuCoreNumber;  
    private List<Future<Long>> tasks = new ArrayList<Future<Long>>();  
  
    // 内部类  
    class SumCalculator implements Callable<Long> {  
        private int[] numbers;  
        private int start;  
        private int end;  
  
        public SumCalculator(final int[] numbers, int start, int end) {  
            this.numbers = numbers;  
            this.start = start;  
            this.end = end;  
        }  
  
        public Long call() throws Exception {  
            Long sum = 0l;  
            for (int i = start; i < end; i++) {  
                sum += numbers[i];  
            }  
            return sum;  
        }  
    }  
  
    public ConcurrentCalculator() {  
        cpuCoreNumber = Runtime.getRuntime().availableProcessors();  
        exec = Executors.newFixedThreadPool(cpuCoreNumber);  
    }  
  
    public Long sum(final int[] numbers) {  
        // 根据CPU核心个数拆分任务，创建FutureTask并提交到Executor  
        for (int i = 0; i < cpuCoreNumber; i++) {  
            int increment = numbers.length / cpuCoreNumber + 1;  
            int start = increment * i;  
            int end = increment * i + increment;  
            if (end > numbers.length)  
                end = numbers.length;  
            SumCalculator subCalc = new SumCalculator(numbers, start, end);  
            FutureTask<Long> task = new FutureTask<Long>(subCalc);  
            tasks.add(task);  
            if (!exec.isShutdown()) {  
                exec.submit(task);  
            }  
        }  
        return getResult();  
    }  
  
    /** 
     * 迭代每个只任务，获得部分和，相加返回 
     *  
     * @return 
     */  
    public Long getResult() {  
        Long result = 0l;  
        for (Future<Long> task : tasks) {  
            try {  
                // 如果计算未完成则阻塞  
                Long subSum = task.get();  
                result += subSum;  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } catch (ExecutionException e) {  
                e.printStackTrace();  
            }  
        }  
        return result;  
    }  
  
    public void close() {  
        exec.shutdown();  
    }  
    public static void main(String[] args) throws ExecutionException,InterruptedException {
        int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 10, 11 };  
        ConcurrentCalculator calc = new ConcurrentCalculator();  
        Long sum = calc.sum(numbers);  
        System.out.println(sum);  
        calc.close();  
    }
}


    在刚在的例子中，getResult()方法的实现过程中，迭代了FutureTask的数组，如果任务还没有完成则当前线程会阻塞，如果我们希望任意字任务完成后就把其结果加到result中，而不用依次等待每个任务完成，可以使CompletionService。生产者submit()执行的任务。使用者take()已完成的任务，并按照完成这些任务的顺序处理它们的结果 。也就是调用CompletionService的take方法是，会返回按完成顺序放回任务的结果，CompletionService内部维护了一个阻塞队列BlockingQueue，如果没有任务完成，take()方法也会阻塞。修改刚才的例子使用CompletionService：
    例3：
     
package com.paincupid.springmvc;

import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrentCalculator2 {  
    
    private ExecutorService exec;  
    private CompletionService<Long> completionService;  
  
  
    private int cpuCoreNumber;  
  
    // 内部类  
    class SumCalculator implements Callable<Long> {  
    	private int[] numbers;  
        private int start;  
        private int end;  
  
        public SumCalculator(final int[] numbers, int start, int end) {  
            this.numbers = numbers;  
            this.start = start;  
            this.end = end;  
        }  
  
        public Long call() throws Exception {  
            Long sum = 0l;  
            for (int i = start; i < end; i++) {  
                sum += numbers[i];  
            }  
            return sum;  
        }  
    }  
  
    public ConcurrentCalculator2() {  
        cpuCoreNumber = Runtime.getRuntime().availableProcessors();  
        exec = Executors.newFixedThreadPool(cpuCoreNumber);  
        completionService = new ExecutorCompletionService<Long>(exec);  
  
  
    }  
  
    public Long sum(final int[] numbers) {  
        // 根据CPU核心个数拆分任务，创建FutureTask并提交到Executor  
        for (int i = 0; i < cpuCoreNumber; i++) {  
            int increment = numbers.length / cpuCoreNumber + 1;  
            int start = increment * i;  
            int end = increment * i + increment;  
            if (end > numbers.length)  
                end = numbers.length;  
            SumCalculator subCalc = new SumCalculator(numbers, start, end);   
            if (!exec.isShutdown()) {  
                completionService.submit(subCalc);  
  
  
            }  
              
        }  
        return getResult();  
    }  
  
    /** 
     * 迭代每个只任务，获得部分和，相加返回 
     *  
     * @return 
     */  
    public Long getResult() {  
        Long result = 0l;  
        for (int i = 0; i < cpuCoreNumber; i++) {              
            try {  
                Long subSum = completionService.take().get();  
                result += subSum;             
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } catch (ExecutionException e) {  
                e.printStackTrace();  
            }  
        }  
        return result;  
    }  
  
    public void close() {  
        exec.shutdown();  
    }  
    public static void main(String[] args) throws ExecutionException,InterruptedException {
        int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 10, 11 };  
        ConcurrentCalculator calc = new ConcurrentCalculator();  
        Long sum = calc.sum(numbers);  
        System.out.println(sum);  
        calc.close();  
    }
}


    最后附上类图关系：


   
Java中ExecutorService线程的Callable的future.get()方法堵塞当前线程解决方法
BADAO_LIUMANG_QIZHI的博客
08-09 3088
在上面学习线程池ExecutorService的使用，实现Callable接口，并获取返回结果时需要注意future的get()方法会堵塞当前线程的执行。即当前线程执行结束并获取到结果之后才会继续执行下个线程。这样就无法实现多线程的效果。执行效果为注：博客：关注公众号霸道的程序猿获取编程相关电子书、教程推送与免费下载。...
ExecutorService、Callable、Future实现有返回结果的多线程原理解析
java1527的博客
09-25 513
以上就是执行线程任务run方法后，如何将线程任务结果返回给主线程，其实，还少一个地方补充，就是如何将FutureTask任务丢给线程执行，我们这里用到了线程池， 但是execute(ftask)底层同样是使用一个了线程通过执行start方法开启一个线程，这个新运行的线程最终会执行FutureTask的run方法。因此，我自定义了一个实现Callable接口的类，该类的重写了call方法，我们在执行多线程时希望返回什么样的结果，就可以在该重写的call方法定义。
Java多线程 ExecutorService Callable Future使用
cndn20120225的博客
04-13 229
需求：查询int数组中最大值 package test; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors...
ExecutorService线程池使用、Future、Callable 接口
最新发布
m0_61160520的博客
08-21 1061
Callable 本身并不能直接运行，它需要通过某种方式提交给执行器（如 ExecutorService）或包装成 FutureTask 然后在一个线程中执行。这是因为 Callable 接口本身只是一个定义了 call 方法的接口，它并不包含任何执行机制。
Java多线程之Executor、ExecutorService、Executors、Callable、Future与FutureTask
JabamiYu的博客
03-20 398
原文地址:https://www.cnblogs.com/zhrb/p/6372799.html 1. 引子 初学Java多线程，常使用Thread与Runnable创建、启动线程。如下例: Thread t1 = new Thread(new Runnable() { @Override public void run() { System.o...
Java多线程之Executor框架<Callable、Future、Executor和ExecutorService>
chetianyao8457的博客
07-19 776
引言 Executor框架是指JDK 1.5中引入的一系列并发库中与Executor相关的功能类，包括Executor、Executors、ExecutorService、Future、Callable等。 一、为什么要引入Executor框架？ 1、如果使用new Thread(......
Callable,Future,ExecutorService的使用
qq_38742043的博客
02-24 491
参考：https://www.cnblogs.com/fengsehng/p/6048609.html  这篇博客介绍得很详细； Callable，简单来说，Callable就是我们以前写的Runnable，就是一个线程要执行的具体程序块，告诉线程要干什么相较于Runnable他可以使用泛型定义返回值，我们可以方便的获取到线程的执行结果； @Override public ThreeDMo...
详解JDK中ExecutorService与Callable和Future对线程的支持
08-29
Java并发编程中的ExecutorService、Callable和Future Java并发编程中，ExecutorService、Callable和Future是三大核心组件，它们之间紧密相连，共同实现了高效、安全的并发编程。下面我们将详细介绍这些组件的作用和...
第六章 使用 Callable 和 Future 的 Java ExecutorService 示例
we
07-20 260
我们将创建一个用于计算平方的可调用对象和一个用于阶乘的调用对象。可调用接口表示可以返回值的线程。可调用接口可用于计算可以返回给调用线程的状态或结果。例如假设您要执行某些数字的阶乘和平方，您可以使用可调用接口同时执行，该接口也将返回值。您可以在调用方法中定义要执行的任务。如果执行成功，调用方法将返回结果，否则必须抛出异常。是通用接口，表示将由可调用接口返回的值。如您所见，我们能够同时执行4个任务，它们返回20和25的平方和阶乘。当这个方法被调用时，线程只会在指定的时间内等待结果。...
Java多线程（ExecutorService 、Executors、Callable、Future、FutureTask）
Kikityer的博客
11-21 491
前言：我们一般通过继承Thread类重写run方法或者实现runnable接口重写run方法，最后创建和启动一个线程，但是都需要自己创建、启动Thread对象。线程池可以实现帮助我们管理Thread对象，至于要使用几个线程，什么时候启动这些线程，是开启多个线程还是用单个线程来完成这些任务，我们无需操心。 Java通过Executors提供四种线程池  newCachedThreadPool...
Java 多线程：Executor、ExecutorService、Executors、Callable、Future与FutureTask
tumu6889的博客
06-10 687
java 多线程
Java并发编程之Future，ExecutorService，Callable讲解实例
Iamthedoctor123的博客
02-17 1365
并发接口 位置：java/util/concurrent（多线程并发，J.U.C）： 接口： Callable（类似Runnable）, Executor（线程池）, Future(线程执行结果), FutureTask（线程任务）， Excutors(线程池工厂，可创建ExecutorService)。。。 这里的并发是针对多线程而言的，在java中创建线程有四种方式： 1）继...
ExecutorService、Callable＜Class＞、Future 有返回值线程
Syea0425的博客
07-19 304
有返回值的任务必须实现 Callable 接口，类似的，无返回值的任务必须 Runnable 接口。执行 Callable 任务后，可以获取一个 Future 的对象，在该对象上调用 get 就可以获取到 Callable 任务 返回的 Object 了，再结合线程池接口 ExecutorService 就可以实现传说中有返回结果的多线程 了。 //创建一个线程池 ExecutorService pool = Executors.newFixedThreadPool(taskSize);
ExecutorService 线程池及 Callable, Future, CompletableFuture
yichudu
01-28 1220
1.ThreadPoolExecutor java.util.concurrent.ThreadPoolExecutor 类。用于接收提交的任务，放到线程池中运行。 java.util.concurrent.ThreadPoolExecutor.ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAlive
使用ExecutorService、Callable、Future实现有返回结果的线程
pdw2009的专栏
02-26 3313
 可返回值的任务必须实现Callable接口 无返回值的任务必须实现Runnable接口 执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object 注意：get方法是阻塞的，即：线程无返回结果，get方法会一直等待   例子1： /** * 有返回值的线程 */ @SuppressWarnings("unc...
Runnable,Callable,Future,RunnableFuture,FutureTask,ExecutorService的关系
YanRu的专栏
08-04 1227
如图：
ExecutorService+Callable+Future实现多线程控制并发数并返回数据
张钦的博客
12-20 1720
一、开始 多任务并行执行阻塞等待全部执行完毕，通过线程池控制并发数。 前半部分为代码（按照执行流程罗列），后半部分为相关注释。 二、创建带有返回数据的Callable public Callable<String> get(String key, Map<String, Object> params) { return () -> { System.out....
Java8基础之Callable、Futrue、Executors和ExecutorService使用
编程学习者的博客
10-12 1637
1.查看Callable的api 2.查看Callable的接口中的方法 一个可以获取结果的执行的线程 3.查看Future接口的api 4.查看Future接口中的内容 用于获取执行后的结果的接口 5.查看Executors工具类的api 6.查看Executors中的方法 一个用于创建ExecutorService的工具类 7.查看ExecutorService的api 8.查看...
Java并发编程：详解Callable与Future接口及其应用
FutureTask是Future接口的典型实现，它结合了Callable的任务执行和Future的结果获取功能，通常用于与ExecutorService配合使用，创建可取消的异步任务。 总结来说，Callable和Future在Java并发编程中扮演着核心角色...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值