一、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)
Executor的子接口有:ExecutorService,ScheduledExecutorService,
已知实现类: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();
ExecutorService 并不会马上关闭,而是不再接收新的任务,一旦所有的线程结束执行当前任务,ExecutorServie 才会真的关闭。所有在调用
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));
}
}
}
4.
ExecutorService 的实现。实现类:ThreadPoolExecutor、ScheduledThreadPollExecutor
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;
第一种,没有异常的,100个线程组合,定义的是不变的线程池,10个,同样打印语句也是个线程,打印结束并不代表已经真的结束
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(),会打印出异常信息,后面的结果不会显示