javaExecutor线程池中的Callable多线程讲解及实例Executor：是Java线程池的超级接⼝；提供⼀个execute(Runnable command)⽅法；我们⼀般⽤它的继承接⼝ExecutorService。
Executors：是urrent包下的⼀个类，提供了若⼲个静态⽅法，⽤于⽣成不同类型的线程池。Executors⼀共可以创建下⾯这四类线程池：
1. newFixedThreadPool创建⼀个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若⽆可回收，则新建线程。
2. newFixedThreadPool 创建⼀个定长线程池，可控制线程最⼤并发数，超出的线程会在队列中等待。
3. newScheduledThreadPool 创建⼀个线程池，它可安排在给定延迟后运⾏命令或者定期地执⾏。
4. newSingleThreadExecutor 创建⼀个使⽤单个 worker 线程的 Executor，以⽆界队列⽅式来运⾏该线程。它只会⽤唯⼀的⼯作线程来执⾏任务，保证所有任务按照指
定顺序(FIFO, LIFO, 优先级)执⾏。
ExecutorService：它是线程池定义的⼀个接⼝，继承Executor。有两个实现类，分别为
ThreadPoolExecutor,ScheduledThreadPoolExecutor。
线程池的继承树：
ExecutorService常⽤的⼏个⽅法：
1. execute(Runnable)从⽗类继承过来的⽅法
2. submit(Runnable)
3. submit(Callable)
4. invokeAny(...)
5. invokeAll(...)
6. shutdown()
execute⽅法：⽅法接收⼀个Runnable实例，并且异步的执⾏，请看下⾯的实例：
public class Demo1 {
public static void main(String[] args) {
ExecutorService executorService = wSingleThreadExecutor(); //创建⼀个单线程
public void run() {
System.out.println("Asynchronous task");
}
});
executorService.shutdown();
}
}
这个⽅法有个问题，就是没有办法获知task的执⾏结果。如果我们想获得task的执⾏结果，我们可以传⼊⼀个Callable的实例（下⾯会介绍）。
submit(Runnable)⽅法：返回⼀个Future对象，通过返回的Future对象，我们可以检查提交的任务是否执⾏完毕。
public class Demo2 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = wSingleThreadExecutor(); //创建⼀个单线程
Future future = executorService.submit(new Runnable() { //接收⼀个Runnable实例
public void run() {
System.out.println("Asynchronous task");
}
});
System.out.()); //任务执⾏结束返回null.
executorService.shutdown();
}
}
submit(Callable)：与submit(Callable)类似，也会返回⼀个Future对象，但是除此之外，submit(Callable)接收的是⼀个Callable的实
现，Callable接⼝中的call()⽅法有⼀个返回值，可以返回任务的执⾏结果，⽽Runnable接⼝中的run()⽅法是void的，没有返回值。
public class Demo1 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = wSingleThreadExecutor(); //创建⼀个单线程
Future<Object> future = executorService.submit(new Callable<Object>() { //接收⼀个Callable实例
public Object call() {
System.out.println("Asynchronous task");
return "Callable Result";
}
});
System.out.println("()="+());
executorService.shutdown();
}
}
invokeAny(...)：⽅法接收的是⼀个Callable的集合，执⾏这个⽅法不会返回Future，但是会返回所有Callable任务中其中⼀个任务的执⾏结果。这个⽅法也⽆法保证返回的是哪个任务的执⾏结果，反正是其中的某⼀个。
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = wSingleThreadExecutor();
Set<Callable<String>> callables = new HashSet<Callable<String>>();
callables.add(new Callable<String>(){
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "Result1";
}
});
callables.add(new Callable<String>(){
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "Result2";
}
});
callables.add(new Callable<String>(){
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "Result3";java线程池创建的四种
}
});
String result = executorService.invokeAny(callables);
System.out.println(result);
executorService.shutdown();
}
}
invokeAll(...)：与 invokeAny(...)类似也是接收⼀个Callable集合，但是前者执⾏之后会返回⼀个Future的List，其中对应着每个Callable任务执⾏后的Future对象。
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = wSingleThreadExecutor();
Set<Callable<String>> callables = new HashSet<Callable<String>>();
callables.add(new Callable<String>(){
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "Result1";
}
});
callables.add(new Callable<String>(){
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "Result2";
}
});
callables.add(new Callable<String>(){
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "Result3";
}
});
List<Future<String>> futures = executorService.invokeAll(callables); //返回⼀个Future的List集合
for(Future<String> future:futures){
System.out.println("()="+());
}
executorService.shutdown();
}
}
shutdown()：我们使⽤完成ExecutorService之后应该关闭它，否则它⾥⾯的线程会⼀直处于运⾏状态。
举个例⼦，如果的应⽤程序是通过main()⽅法启动的，在这个main()退出之后，如果应⽤程序中的ExecutorService没有关闭，这个应⽤将⼀直运⾏。之所以会出现这种情况，是因为ExecutorService中运⾏的线程会阻⽌JVM关闭。
如果要关闭ExecutorService中执⾏的线程，我们可以调⽤ExecutorService.shutdown()⽅法。在调⽤shutdown()⽅法之后，ExecutorService 不会⽴即关闭，但是它不再接收新的任务，直到当前所有线程执⾏完成才会关闭，所有在shutdown()执⾏之前提交的任务都会被执⾏。
如果我们想⽴即关闭ExecutorService，我们可以调⽤ExecutorService.shutdownNow()⽅法。这个动作将跳过所有正在执⾏的任务和被提交还没有执⾏的任务。但是它并不对正在执⾏的任务做任何保证，有可能它们都会停⽌，也有可能执⾏完成。
下⾯贴出个实际的例⼦：
package main.java;
import java.sql.Time;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import urrent.Callable;
import urrent.CancellationException;
import urrent.ExecutionException;
import urrent.ExecutorService;
import urrent.Executors;
import urrent.Future;
import urrent.TimeUnit;
/**
* 批量任务的限时 invokeAll(tasks) 批量提交不限时任务
*
* invokeAll(tasks, timeout, unit) 批量提交限时任务
*
* InvokeAll⽅法处理⼀个任务的容器（collection），并返回⼀个Future的容器。两个容器具有相同的结构：
* invokeAll将Future添加到返回的容器中，这样可以使⽤任务容器的迭代器，从⽽调⽤者可以将它表现的Callable与Future 关联起来。
* 当所有任务都完成时、调⽤线程被中断时或者超过时限时，限时版本的invokeAll都会返回结果。超过时限后，任务尚未完成的任务都会被取消。
*
*
*
*/
public class InvokeAllThread {
// 固定⼤⼩的线程池，同时只能接受5个任务
static ExecutorService mExecutor = wCachedThreadPool();
/**
* 计算价格的任务
*
* @author hadoop
*
*/
private class QuoteTask implements Callable<Integer> {
public final double price;
public final int num;
public QuoteTask(double price, int num) {
this.price = price;
this.num = num;
}
@Override
public Integer call() throws Exception {
Random r = new Random();
long time = (r.nextInt(10) + 1) * 1000;
Thread.sleep(time);
Integer d = Integer.valueOf((int) (price * num));
System.out.println("耗时：" + time / 1000 + "s，单价是：" + price + ",⼈数是：" + num + "，总额是：" + d);
return d;
}
}
/**
* 在预定时间内请求获得旅游报价信息
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论