一、Exectuor框架简介
Java从1.5版本开始，为简化多线程并发编程，引入全新的并发编程包：java.util.concurrent及其并发编程框架（Executor框架）。 Executor框架是指java 5中引入的一系列并发库中与executor相关的一些功能类，其中包括线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。在Executor框架中，使用执行器(Exectuor)来管理Thread对象，从而简化了并发编程。
二、认识Exectuor（执行器）
1、执行任务，Executor在执行时使用其内部的线程池来完成操作。等同于：new Thread(new (RunnableTask())).start()
Executor.execute(Runnalbe)已知实现类：AbstractExecutorService,ScheduledThreadPoolExecutor,ThreadPoolExecutor。
2.ThreadPoolExecutor类提供了一个可供可扩展的线程池实现。Executors类为Executor接口及其实现提供了便捷的工厂方法。
Executor executor = Executors.newCachedThreadPool();3.Executor中的方法execute。void execute(Runnable command)表示在未来的某个时间执行给定的命令。该命令可能在新的线程、已经入池的线程
或者正在调用的线程中执行。
三、Executors类： 主要用于提供线程池相关的操作
Executors类，提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。
1、public static ExecutorService newFiexedThreadPool(int Threads) 创建固定数目线程的线程池。
2、public static ExecutorService newCachedThreadPool()： 创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。
如果没有可用的线程，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
3、public static ExecutorService newSingleThreadExecutor()： 创建一个单线程化的Executor。
4、public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。
四、ExecutorService
1.ExecutorService可以理解为程序员提供了一堆操作Executor的API。
2.ExecutorService扩展了Executor并添加了一些生命周期管理的方法。三种状态：运行、关闭和终止。
Executor创建时处于运行状态。
executorService.shutdown();shutdown() 方法之前提交到 ExecutorService 的任务都会执行。
Executor处于关闭状态。
调用shutdownNow()，这个方法会尝试马上关闭所有正在执行的任务，并且跳过所有已经提交但是还没有运行的任务。但是对于正在执行的任务，
是否能够成功关闭它是无法保证的，有可能他们真的被关闭掉了，也有可能它会一直执行到任务结束。
isShutdown()判断当前是否是关闭状态。
isTerminated()判断当前是否执行所有任务。
3. ExecutorService 的实现就是一个线程池的实现。
package zjq.test.threadpool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CachedThreadPoolTest {
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 1; i < 101; i++) {
executorService.execute(new ThreadTest("zjq:"+i));
}
}
}
5.ExecutorService 执行方法介绍。
execute(Runnable)：没有返回参数
submit(Runnable)：返回一个Future，为null
submit(Callable)：返回一个Future，代码如下：
package zjq.test.threadpool;
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 implements Callable<String>{
@Override
public String call() throws Exception {
System.out.println("********test*******");
return "test";
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newCachedThreadPool();
Future<String> future = executorService.submit(new CallableTest());//Callable<String>
System.out.println(future.get());
Future<?> submit = executorService.submit(new ThreadTest("zjq"));//Runnable
System.out.println(submit.get());
}
}
inVokeAny()针对Callable，返回<T>，用例：当你要搜索本地磁盘上某一类文件时，而且这类文件集中在一起，假如有五个盘， 开启五个线程，当某个
线程找到了，则立即返回结果，其他四个线程立即停止；没找到，抛出一个异常，此盘没有这类文件。
/**
* Executes the given tasks, returning the result //执行一组线程集合，得到一个随机结果（如果有异常，继续执行，直到成功执行任务返回结果），随后关闭
* of one that has completed successfully (i.e., without throwing //正在进行或还未进行的线程
* an exception), if any do. Upon normal or exceptional return,
* tasks that have not completed are cancelled.
* The results of this method are undefined if the given
* collection is modified while this operation is in progress.
*
* @param tasks the collection of tasks
* @return the result returned by one of the tasks
* @throws InterruptedException if interrupted while waiting
* @throws NullPointerException if tasks or any element task
* subject to execution is <tt>null</tt>
* @throws IllegalArgumentException if tasks is empty
* @throws ExecutionException if no task successfully completes
* @throws RejectedExecutionException if tasks cannot be scheduled
* for execution
*/
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException;package zjq.test.threadpool;
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.TimeUnit;
public class CallableInVokeAnyTest implements Callable<String>{
private String name;
public CallableInVokeAnyTest(String name) {
this.name = name;
}
@Override
public String call() throws Exception {
System.out.println(name+"执行开始");
TimeUnit.SECONDS.sleep(3);
System.out.println(name+"执行结束");
return name;
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newFixedThreadPool(10);
List<CallableInVokeAnyTest> list = new ArrayList<>();
for (int i = 0; i < 100; i++) {
list.add(new CallableInVokeAnyTest("zjq"+i));
}
String invokeAny = executorService.invokeAny(list);
System.out.println("****************"+invokeAny);
executorService.shutdownNow();
}
}
zjq0执行开始
zjq1执行开始
zjq2执行开始
zjq3执行开始
zjq4执行开始
zjq5执行开始
zjq6执行开始
zjq8执行开始
zjq9执行开始
zjq7执行开始
zjq2执行结束
zjq8执行结束
zjq7执行结束
zjq6执行结束
zjq0执行结束
zjq5执行结束
zjq4执行结束
zjq3执行结束
zjq1执行结束
****************zjq2
zjq13执行开始
zjq12执行开始
zjq10执行开始
zjq11执行开始
zjq9执行结束
从结果可以看出，获取的是线程zjq2，说明线程zjq2已经成功执行完成，机制是挑选最先完成的
第二种，线程中有出现异常的
package zjq.test.threadpool;
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.TimeUnit;
public class CallableInVokeAnyTest implements Callable<String>{
private String name;
public CallableInVokeAnyTest(String name) {
this.name = name;
}
@Override
public String call() throws Exception {
System.out.println(name+"执行开始");
TimeUnit.SECONDS.sleep(3);
if (name.contains("3")) {
System.out.println(name+"有异常");
throw new Exception("空指针异常");
}
System.out.println(name+"执行结束");
return name;
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newFixedThreadPool(10);
List<CallableInVokeAnyTest> list = new ArrayList<>();
for (int i = 0; i < 100; i++) {
list.add(new CallableInVokeAnyTest("zjq"+i));
}
String invokeAny = executorService.invokeAny(list);
System.out.println("****************"+invokeAny);
executorService.shutdownNow();
}
}
zjq0执行开始
zjq2执行开始
zjq1执行开始
zjq3执行开始
zjq4执行开始
zjq5执行开始
zjq6执行开始
zjq7执行开始
zjq8执行开始
zjq9执行开始
zjq5执行结束
zjq1执行结束
zjq0执行结束
zjq3有异常
zjq11执行开始
zjq4执行结束
zjq2执行结束
zjq6执行结束
****************zjq5
zjq7执行结束
zjq9执行结束
zjq12执行开始
zjq8执行结束
zjq10执行开始
结果可以看出，有异常不会立即抛出，会继续下个线程执行，直到返回结果
第三种，全部不同，且异常不同，只有一个线程是正常的
package zjq.test.threadpool;
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.TimeUnit;
public class CallableInVokeAnyTest implements Callable<String>{
private String name;
public CallableInVokeAnyTest(String name) {
this.name = name;
}
@Override
public String call() throws Exception {
int nameInt = Integer.parseInt(name);
System.out.println(name+"执行开始");
// TimeUnit.SECONDS.sleep(3);
if (nameInt<50) {
System.out.println(name+"有异常");
throw new NullPointerException("空指针异常");
}else if(nameInt>50){
System.out.println(name+"有异常");
throw new IndexOutOfBoundsException("空指针异常");
}
System.out.println(name+"执行结束");
return name;
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newFixedThreadPool(10);
List<CallableInVokeAnyTest> list = new ArrayList<>();
for (int i = 0; i < 100; i++) {
list.add(new CallableInVokeAnyTest(i+""));
}
String invokeAny = executorService.invokeAny(list);
System.out.println("****************"+invokeAny);
executorService.shutdownNow();
}
}
50执行结束
51有异常
61执行开始
61有异常
55执行开始
55有异常
58有异常
52有异常
54有异常
56执行开始
****************50
60执行开始
60有异常
57有异常
59执行开始
59有异常
56有异常
结果可以看出，一定会打印50这个线程，其他线程不会结束，同样如果全部都是异常的，所有线程都会跑完，程序会一直运行，抛出其中的第一个异常。
invokeAll()针对Callable，返回List<Future<T>>，得到所有线程的返回结果
说下特殊情况，如果其中有异常会怎么办？
package zjq.test.threadpool;
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 CallableInVokeAllTest implements Callable<String>{
private String name;
public CallableInVokeAllTest(String name) {
this.name = name;
}
@Override
public String call() throws Exception {
int nameInt = Integer.parseInt(name);
System.out.println(name+"执行开始");
if(nameInt>20&&nameInt<90){
System.out.println(name+"有异常");
throw new IndexOutOfBoundsException("数组越界异常");
}
return name;
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newFixedThreadPool(10);
List<CallableInVokeAllTest> list = new ArrayList<>();
for (int i = 0; i < 100; i++) {
list.add(new CallableInVokeAllTest(i+""));
}
List<Future<String>> invokeAll = executorService.invokeAll(list);
for (Future<String> future : invokeAll) {
System.out.println("****"+future.isCancelled());
System.out.println("****"+future.isDone());
System.out.println("****"+future.get());
}
executorService.shutdownNow();
}
}
.
.
****false
****true
****19
****false
****true
****20
****false
****true
Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.IndexOutOfBoundsException: 数组越界异常
at java.util.concurrent.FutureTask.report(FutureTask.java:122)
at java.util.concurrent.FutureTask.get(FutureTask.java:188)
at zjq.test.threadpool.CallableInVokeAllTest.main(CallableInVokeAllTest.java:39)
Caused by: java.lang.IndexOutOfBoundsException: 数组越界异常
结果可以看出，调用future.get()，会打印出异常信息，后面的结果不会显示
323
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
