1.Executor框架
Executor只是个简单的接口,但它却为一个灵活而且强大的框架创造了基础,这个框架可异步执行,支持不同类型的任务执行策略。
public interface Executor {
void execute(Runnable command);
}
2.创建线程池
通过Executors中的某个静态工厂方法来创建一个线程池:
newFixedThreadPool:创建一个定长的线程池,每提交一个任务创建一个线程,直道到达池的最大长度。
newCachedThreadPool:创建一个可缓存的线程池,如果当前线程池的长度超过处理需求时,它可灵活的回收空闲线程,当需要增加时,可灵活的添加新线程,而不会对池的长度做任何的限制。
newSingleThreadExecutor:创建一个单线程划的executor,它创建唯一的工作者线程来执行任务,如果线程异常结束,将会有另外一个来取代他。
newScheduledThreadPool:创建一个定长的线程池,支持定时的以及周期性的任务执行。
3.ExecutorService
ExecutorService扩展了Executor且添加了用户生命周期(运行,关闭,终止)的方法。
Shutdown():启动一个平缓的关闭过程:停止接收新的任务,同时等待已经提交的任务完成,包括尚未开始执行的任务。
ShutdownNow():启动一个强制的关闭过程:尝试取消所有运行中的任务与排队在队列中尚未开始的任务。
终止:可调用awaitTermination(long timeout,TimeUnit unit) 等待ExecutorService达到终止状态,也可以用i isTerminated来判断ExecutorService是否已近终止。通常shutdown会紧随awaitTermination之后,这样可以同步的关闭ExecutorService的效果。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test {
public static void main(String[] args) {
ExecutorService service1 = Executors.newCachedThreadPool();
for(int i = 1; i < 4; i++){
service1.execute(new Task(i));
}
service1.shutdown();
// ExecutorService service2 = Executors.newFixedThreadPool(2);
// for(int i = 1; i < 4; i++){
// service2.execute(new Task(i));
// }
// service2.shutdown();
// ExecutorService service3 = Executors.newSingleThreadExecutor();
// for(int i = 1; i < 4; i++){
// service3.execute(new Task(i));
// }
// service3.shutdown();
}
}
class Task implements Runnable{
private int i;
public Task(int i) {
this.i = i;
}
@Override
public void run() {
try {
Thread.sleep(1000);
System.out.println("current thread " + i + " is running");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
4.CompletionService:
CompletionService整合了Executor和BlockingQueue的功能。你可以将callable任务提交给他执行,然后类似队列的take和poll方法,在结果完整可用时获取结果。CompletionService的实现是维护一个保存Future对象的BlockingQueue。
poll:非阻塞,若目前无结果,返回null。
take:阻塞,若当前无结果,则阻塞至返回结果。
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CompletionTask {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
for(int i = 1; i <= 100; i++){
list.add(i);
}
ExecutorService service = Executors.newCachedThreadPool();
CompletionService<Integer> com = new ExecutorCompletionService<>(service);
List<Integer> numbers = new ArrayList<>();
for(int i = 1; i <= 100; i++){
if(i % 10 == 0){
com.submit(new Task(numbers));
numbers = new ArrayList<>();
numbers.add(i);
}else{
numbers.add(i);
}
}
service.shutdown();
int result = 0;
try {
for(int i=0;i<10;i++){
Future<Integer> future = com.take();
int res = future.get();
result = result + res;
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("执行结果为:"+result);
}
}
class Task implements Callable<Integer>{
private List<Integer> numbers;
public Task(List<Integer> numbers) {
this.numbers = numbers;
}
@Override
public Integer call() throws Exception {
int sum = 0;
for(Integer num : numbers){
sum = sum + num;
}
return sum;
}
}
当然执行结果为4950