concurrent: Callable用法

转载自: http://auguslee.iteye.com/blog/1292335

Callable 和 Runnable 的使用方法大同小异, 区别在于:
1.Callable 使用 call() 方法, Runnable 使用 run() 方法
2.call() 可以返回值, 而 run()方法不能返回。
3.call() 可以抛出受检查的异常,比如ClassNotFoundException, 而run()不能抛出受检查的异常。
Callable示例如下:
 
class TaskWithResult implements Callable<String> {
	private int id;

	public TaskWithResult(int id) {
		this.id = id;
	}

	@Override
	public String call() throws Exception {
		return "result of TaskWithResult " + id;
	}
}

public class CallableTest {
	public static void main(String[] args) throws InterruptedException,
			ExecutionException {
		ExecutorService exec = Executors.newCachedThreadPool();
		ArrayList<Future<String>> results = new ArrayList<Future<String>>();	//Future 相当于是用来存放Executor执行的结果的一种容器
		for (int i = 0; i < 10; i++) {
			results.add(exec.submit(new TaskWithResult(i)));
		}
		for (Future<String> fs : results) {
			if (fs.isDone()) {
				System.out.println(fs.get());
			} else {
				System.out.println("Future result is not yet complete");
			}
		}
		exec.shutdown();
	}
}

执行结果
result of TaskWithResult 0
result of TaskWithResult 1
result of TaskWithResult 2
result of TaskWithResult 3
result of TaskWithResult 4
result of TaskWithResult 5
result of TaskWithResult 6
result of TaskWithResult 7
result of TaskWithResult 8
result of TaskWithResult 9

Runnable示例:

   

  

public class LiftOff implements Runnable {

	protected int countDown = 10;
	private static int taskCount = 0;
	private final int id = taskCount++;

	public LiftOff() {

	}

	public LiftOff(int countDown) {
		this.countDown = countDown;
	}

	public String status() {
		return "#" + id + "(" + (countDown > 0 ? countDown : "LiftOff! ") + ")";
	}

	@Override
	public void run() {
		while (countDown-- > 0) {
			System.out.print(status());
			Thread.yield();
		}
		System.out.println();
	}

	public static void main(String[] args) {
		ExecutorService exec = Executors.newFixedThreadPool(1);
		for (int i = 0; i < 5; i++) {
			exec.execute(new LiftOff());
		}
		exec.shutdown();
	}
}

执行结果
#0(9)#0(8)#0(7)#0(6)#0(5)#0(4)#0(3)#0(2)#0(1)#0(LiftOff! )
#1(9)#1(8)#1(7)#1(6)#1(5)#1(4)#1(3)#1(2)#1(1)#1(LiftOff! )
#2(9)#2(8)#2(7)#2(6)#2(5)#2(4)#2(3)#2(2)#2(1)#2(LiftOff! )
#3(9)#3(8)#3(7)#3(6)#3(5)#3(4)#3(3)#3(2)#3(1)#3(LiftOff! )
#4(9)#4(8)#4(7)#4(6)#4(5)#4(4)#4(3)#4(2)#4(1)#4(LiftOff! )

注意ExecutorService 在Callable中使用的是submit(), 在Runnable中使用的是 execute()
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 可以使用 Python 的 concurrent.futures 库中的 ThreadPoolExecutor 类来使用 callable 和 future 创建线程。首先,需要创建一个 ThreadPoolExecutor 实例,然后使用 submit() 方法将 callable 包装在一个 future 对象中并提交给线程池执行。例如: ``` from concurrent.futures import ThreadPoolExecutor def my_function(): # do something executor = ThreadPoolExecutor() future = executor.submit(my_function) # do other things result = future.result() # block until the function is complete and return the result ``` 在这种情况下, `my_function` 将在另一个线程中运行,并且可以使用 `future.result()` 来阻塞等待结果并获取返回值。 ### 回答2: 使用 callable 和 future 创建线程的主要目的是为了充分利用多核 CPU 的能力,加速程序的执行速度。 Callable 是一个接口,通常用于表示一个可调用的对象,即一个函数或者一个方法。通过实现 Callable 接口,并重写 call() 方法来创建一个可调用对象。Future 是一个接口,用于表示一个异步计算的结果,它有三种状态:正在进行、已经完成、已经取消。 Callable 和 Future 结合使用,可以实现异步执行一个任务的功能,即先向线程池提交一个 Callable 对象,线程池会为该对象分配一个执行线程,并返回一个 Future 对象。通过调用 Future 对象的 get() 方法,可以等待该计算完成,从而获取返回值。 使用 Callable 和 Future 创建线程的步骤如下: 1. 创建一个 Callable 对象,并实现 call() 方法,该方法返回一个值。 2. 创建一个 ExecutorService 对象,该对象维护着一个线程池。 3. 向线程池提交 Callable 对象,该方法会返回一个 Future 对象。 4. 通过调用 Future 对象的 get() 方法,可以等待 Callable 对象执行完毕,并获取返回值。 例如,下面的代码创建了一个 Callable 对象,并通过 ExecutorService 对象将其提交到线程池中执行,然后通过 Future 对象获取执行的结果: ``` import java.util.concurrent.*; public class CallableDemo { public static void main(String[] args) throws Exception { // 创建一个 Callable 对象 Callable<String> task = () -> { System.out.println("Task is running..."); Thread.sleep(5000); // 模拟一个耗时的操作 return "Hello, World!"; }; // 创建一个 ExecutorService 对象 ExecutorService executor = Executors.newFixedThreadPool(1); // 向线程池提交 Callable 对象,并返回一个 Future 对象 Future<String> future = executor.submit(task); // 等待任务执行完毕,并获取执行的结果 String result = future.get(); System.out.println(result); // 关闭线程池 executor.shutdown(); } } ``` 上述代码创建了一个 Callable 对象 task,该对象模拟了一个耗时的操作,然后创建了一个 ExecutorService 对象 executor,该对象维护着一个固定大小为 1 的线程池。接着,向线程池提交 Callable 对象 task,并返回一个 Future 对象 future。最后,通过调用 Future 对象的 get() 方法等待 Callable 对象 task 执行完毕,并获取执行的结果 result。最后,关闭线程池 executor。 ### 回答3: 使用callable和future创建线程,可以让我们更加灵活地管理线程池和多线程任务。相比于直接使用Thread类创建线程,使用callable可以让我们定义更加灵活的任务,callable既可以返回结果,也可以抛出异常。而使用Future则可以让我们更好地掌控线程的执行状态,比如可以查询某个任务是否已经完成,可以等待某个任务的完成。下面,我将进一步介绍callable和future的用法。 首先,我们需要了解什么是callablecallable是一个接口,其中包含一个call()方法,call()方法包含了要执行的任务。我们可以使用callable创建一个实现了该接口的类的实例,从而将任务封装起来,以便于将该任务提交给线程池执行。创建callable的基本语法如下: ``` class MyCallable implements Callable<Integer> { public Integer call() throws Exception { // 在这里编写任务代码 } } Callable<Integer> callable = new MyCallable(); ``` 上面的代码中,我们创建了一个实现了Callable接口的类MyCallable,该类包含了任务代码,可以返回一个Integer类型的结果。然后,我们创建了一个callable对象,该对象将用于将任务提交给线程池。 接下来,我们需要介绍future。future实现了Future接口,表示一个异步的计算结果。当我们将一个任务提交给线程池执行时,会返回一个Future对象,我们可以通过该对象来监控任务的执行状态,等待任务的完成,并获取任务的结果。创建Future对象的基本语法如下: ``` ExecutorService executor = Executors.newFixedThreadPool(1); Future<Integer> future = executor.submit(callable); ``` 上面的代码中,我们创建了一个线程池executor,将callable对象提交给线程池,并返回了一个future对象,该对象表示了可调用对象的计算结果。 最后,我们需要了解如何使用Future对象监控任务的执行状态和获取结果。Future对象提供了一些方法,可以用于查询任务的执行状态和获取任务的结果。常用的方法包括: 1. isDone():查询任务是否已经完成; 2. get():等待任务完成,并获取任务的结果,如果任务抛出异常,则该方法将会重新抛出该异常。 完整代码如下: ``` import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class CallableFutureDemo { public static void main(String[] args) throws Exception { // 创建可调用对象 Callable<Integer> callable = new MyCallable(); // 创建线程池 ExecutorService executor = Executors.newFixedThreadPool(1); // 提交任务并获取Future对象 Future<Integer> future = executor.submit(callable); // 查询任务状态 while (!future.isDone()) { System.out.println("任务未完成,等待1秒..."); Thread.sleep(1000); } // 获取任务结果 Integer result = future.get(); System.out.println("任务结果:" + result); // 关闭线程池 executor.shutdown(); } } class MyCallable implements Callable<Integer> { public Integer call() throws Exception { System.out.println(Thread.currentThread().getName() + "开始执行任务..."); Thread.sleep(3000); System.out.println(Thread.currentThread().getName() + "完成任务."); return 100; } } ``` 上面的代码中,我们创建了一个可调用对象MyCallable,并且将该对象提交给了一个线程池executor。然后,我们使用了一个while循环,来等待任务完成。一旦任务完成,我们使用future.get()方法获取了任务的结果,并打印了结果。最后,我们调用了executor.shutdown()方法关闭了线程池。 使用callable和future创建线程,可以让我们更加灵活地管理线程池和多线程任务,可以有效提高程序的并发效率和性能。如果需要使用多线程实现异步的任务执行,可以考虑使用callable和future。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值