多线程callable使用方法

Runnable是执行工作的独立任务,但是它不返回任何值。在JavaSE5中引入的Callable是一种具有类型参数的泛型,它的类型参数表的是从方法call()中返回的值,并且必须使用ExecutorServices.submit()方法调用它,下面是一个简单示例。

[java] view plain copy print?

package com.test;
2.
3.import java.util.ArrayList;
4.import java.util.List;
5.import java.util.concurrent.Callable;
6.import java.util.concurrent.ExecutionException;
7.import java.util.concurrent.ExecutorService;
8.import java.util.concurrent.Executors;
9.import java.util.concurrent.Future;
10.
11.public class CallableTest {
12.    public static void main(String[] args) {
13.        ExecutorService exec=Executors.newCachedThreadPool();
14.        List<Future<String>> results=new ArrayList<Future<String>>();
15.
16.        for(int i=0;i<5;i++) {
17.            results.add(exec.submit(new TaskWithResult(i)));
18.        }
19.
20.        for(Future<String> fs :results) {
21.            try {
22.                System.out.println(fs.get());
23.            } catch (InterruptedException e) {
24.                e.printStackTrace();
25.            } catch (ExecutionException e) {
26.                e.printStackTrace();
27.            }
28.        }
29.    }
30.}
31.
32.class TaskWithResult implements Callable<String> {
33.    private int id;
34.    public TaskWithResult(int id) {
35.        this.id=id;
36.    }
37.
38.    @Override
39.    public String call() throws Exception {
40.        return "result of TaskWithResult "+id;
41.    }
42.}
package com.test;

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;

public class CallableTest {
    public static void main(String[] args) {
        ExecutorService exec=Executors.newCachedThreadPool();
        List<Future<String>> results=new ArrayList<Future<String>>();

        for(int i=0;i<5;i++) {
            results.add(exec.submit(new TaskWithResult(i)));
        }

        for(Future<String> fs :results) {
            try {
                System.out.println(fs.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

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;
    }
}

实验结果:

result of TaskWithResult 0 result of TaskWithResult 1 result of TaskWithResult 2 result of TaskWithResult 3 result of TaskWithResult 4

submit()方法回产生Future对象,它用Callable返回结果的特定类型进行了参数化。可以用isDone()方法来查询Future是否已经完成,当任务完成时,它具有一个结果,可以调用get()方法获取该结果。也可以不用isDone()进行检查就直接调用get(),在这种情况下,get()将阻塞,直至结果准备就绪。还可以在试图调用get()来获取结果之前,先调用具有超时的get(),或者调用isDone()来查看任务是否完成。

时间: 2024-10-31 14:20:43

多线程callable使用方法的相关文章

Win32 多线程的创建方法,区别和联系

Win32多线程的创建方法主要有: CreateThread() _beginthread()&&_beginthreadex() AfxBeginThread() CWinThread类 一.简介 CreateThread: Win32提供的创建线程的最基础的API,用于在主线程上创建一个线程.返回一个HANDLE句柄(内核对象).在内核对象使用完毕后,一般需要关闭,使用CloseHandle()函数. _beginthread()&&_beginthreadex():_

一种非常简便的实现Android多线程池的方法

开发Android过程中至少会遇到一个主线程,也称UI线程,这个线程是不允许阻塞的,否则会报错,比如最常见的获取网络资源.读写文件等操作,这些耗时操作都不能再主线程使用.这里介绍一个非常高效又非常简单实用的方法ExecutorService类. ExecutorService类可以理解为线程池,开发者可以实例化一个该对象,在其中使用多个异步进行的操作. ExecutorService接口继承了Executor接口,定义了一些生命周期的方法,如下定义. public interface Execu

多线程的创建方法

- (void)viewDidLoad {    [super viewDidLoad]; //第一种开启新的线程调用 mutableTheard    NSThread * t = [[NSThread alloc]initWithTarget:self selector:@selector(mutableTheard) object:nil];    [t start];            //第二种开启新的线程调用 mutableTheard    [NSThread detachNe

Java多线程死锁避免方法

一.什么是死锁当两个或两个以上的线程在执行过程中,因为争夺资源而造成的一种相互等待的状态,由于存在一种环路的锁依赖关系而永远地等待下去,如果没有外部干涉,他们将永远等待下去,此时的这个状态称之为死锁.经典的 "哲学家进餐" 问题很好地描述了死锁状况:5个哲学家去吃中餐,坐在一张圆桌旁,他们有5根筷子(而不是5双),并且每两个人中间放一根筷子,哲学家们要么在思考,要么在进餐,每个人都需要一双筷子才能吃到东西,并在吃完后将筷子放回原处继续思考,有些筷子管理算法 (1) 能够使每个人都能相对

Java多线程 - Callable和Future

已知的创建多线程的方法有继承Tread类和实现Runnable方法.此外Java还提供了Callable接口,Callable接口也提供了一个call()方法来做为线程执行体.但是call()方法与run()方法有些不同: call()方法可以有返回值 call()方法可以抛出异常 不过Java不允许Callable对象直接作为Thread的target.而且call()方法还有一个返回值--call()方法并不是直接调用,他是做为线程执行体被调用的.Java提供了Future接口来代表Call

java多线程的实现方法

java虚拟机允许应用程序并发地运行多个线程.在java语言中,多线程的实现一般有以下三种方法: 1)实现Runnable接口,并实现该接口的run()方法 class MyThread implements Runnable { public void run(){ System.out.println("Thread Body"); } } public class Test { public static void main(String[] args) { MyThread t

java多线程Callable,Future,FutureTask

我们平时接触到的多线程Thread,Runnable,这两种方式不能返回线程执行后的结果. Callable和Future,前者产生结果,后者拿到结果. Callable和Future 推荐一篇不错的博客:http://blog.csdn.net/ghsau/article/details/7451464 public class GreyStartServlet extends HttpServlet { @Override public void init() throws ServletE

Java多线程Callable和Future类详解

     public interface Callable<V>    返回结果并且可能抛出异常的任务.实现者定义了一个不带任何参数的叫做 call 的方法      public interface Future<V>      Future 表示异步计算的结果.计算完成后只能使用 get 方法来获取结果 1.线程处理返回结果 一般开发中,使用多线程,最常见的就是:1.实现Runnable接口:2.继承Thread类. 但是run方法是没有返回结果,很难满足我们的需求.这时,常

多线程的通信方法

转自 http://www.cnblogs.com/mengyan/archive/2012/08/30/2664607.html 一.进程通信方法 在说明线程通信前,有必要对进程通信进行说明: 进程间通信的方法主要有以下几种:  (1)管道(Pipe):管道可用于具有亲缘关系进程间的通信,允许一个进程和另一个与它有共同祖先的进程之间进行通信.  (2)命名管道(named pipe):命名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关 系 进程间的通信.命名管道