本文介绍了Java 1.5之后的多线程模式，包括Executors、ExecutorService、ScheduledExecutorService等核心类，并通过实际例子展示了如何使用这些类进行多线程操作。此外，文章还探讨了CompletableFuture、CountDownLatch等高级线程工具的应用场景。
内容主要包括之Executors,Executor,ExecutorService,CompletionService,Future,CountDownLauch,Callable,Runnable
在讲1.5之后的多线程模式之前，先简单的说一下1.5之前的线程模式，简单的说就是Thread+Runnable模式。Thread是线程，Runnable可以看做是线程要执行的任务。1.5之前的线程模式的一些缺点：
1 管理多线程有诸多不便，比如：多个线程创建，需要多次new Thread；线程生命周期的管理，和多线程同步，需要对Java多线程的实现有比较深入的了解
2 Runnable没有结果返回，需要某种机制等待线程执行结束，通过通知或者回调获取线程执行的结果
Executors线程框架
由于时间关系，UML简化了，这里画出了本人认为最重要的几个类
类的简要说明
Executors
可以看做是工厂类，主要用于创建和管理Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable
interface ExecutrService
个人觉得看以把ExecutorService看成是多线程的容器，主要用于管理多线程，可以往容器中提交线程，由容器负责线程的生命周期，包括启动，执行，结束线程. 通过上面的类图可以看到我们可以往容器中提交实现Callable或者Runnable接口的类；往容器中提交Callable的实例，将会返回一个Future的对象，这个Future对象可以用于简单的控制Callable对应的线程
interface Callable
跟Runable类似，同样是封装了线程需要的执行任务，执行任务在Callable的call方法中实现，call方法可以看成是Runnable的run方法，唯一不同的是call方法，有一个返回值。我们知道call或者run方法，是由线程框架自己去调用的，那么线程执行结束之后，我们如何获取call方法的返回值呢？我们知道，当往容器中提交Callable实例时，会返回Future类的一个实例。通过Future类的实例，我们可以获取线程结束后(也就是call函数执行完毕)的返回值
interface Future
这个类的基本功能其实在ExecutorService和Callable中已经有提到了，每次往容器中提交Callable或者Runnable任务，都会返回Future的实例；该实例可以简单的管理执行Callable或者Runnable的线程，主要用于获取线程的执行结果，或者查看线程的当前执行状态
interface CompletionService<V>
当我们向容器中提交多个任务时，建设我们提交任务的顺序是task1,task2,task3，我们知道容器是多线程执行任务的，所以任务完成的顺序有可能和任务提交的顺序不一样，比如任务完成的顺序有可能是task2,task1,task3；CompletionService提供了一种机制，可以理解成维护了一个任务完成队列，当容器中有任务完成时，会加入到CompletionService的完成队列中，那么我们通过CompletionService的take 或者 poll方法，每次都能获取剩余任务中，最先执行完的任务
Interface ScheduledExecutorService
用于定时，周期性的执行某一个任务，某些情况下可以代替Timer类
CountDownLatch
这个类在类图中没有画出来，主要用于多线程之间的同步。有点类似Semaphore，当计数值等于0时，将触发事件。
举例1：
Executor executor = Executors.newFixedThreadPool(10);
Runnable task = new Runnable() {
@Override
public void run() {
System.out.println("task executing");
}
};
executor.execute(task);
executor = Executors.newScheduledThreadPool(10);
ScheduledExecutorService scheduler = (ScheduledExecutorService) executor;
scheduler.scheduleAtFixedRate(task, 10, 10, TimeUnit.SECONDS);
举例2：
package com.thread;
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;
/**
* 内核多线程求和，将数据划分成多个数据块，每个数据块交给一个cpu内核线程去计数和，最后在汇总所有数据的和
* http://www.linuxidc.com/Linux/2014-02/96879.htm
* Java1.5后的多线程框架
**/
public class ConcurrentCalculator {
private ExecutorService exec;
private CompletionService<Long> completionService;
private int cpuCoreNumber;
class SumCalculator implements Callable<Long> {
private int[] numbers;
private int start;
private int end;
public SumCalculator(final int[] numers, int start, int end) {
this.numbers = numers;
this.start = start;
this.end = end;
}
public Long call() throws Exception {
Long sum = 0l;
for (int i = start; i < end; i++) {
sum += numbers[i];
}
return sum;
}
}
public ConcurrentCalculator() {
cpuCoreNumber = Runtime.getRuntime().availableProcessors();
exec = Executors.newFixedThreadPool(cpuCoreNumber);
completionService = new ExecutorCompletionService<Long>(exec);
}
public Long sum(final int[] numbers) {
// 根据CPU核心个数拆分任务，创建FutureTask并提交到Executor
for (int i = 0; i < cpuCoreNumber; i++) {
int increment = numbers.length / cpuCoreNumber + 1;
int start = increment * i;
int end = increment * i + increment;
if (end > numbers.length)
end = numbers.length;
SumCalculator subCalc = new SumCalculator(numbers, start, end);
if (!exec.isShutdown()) {
completionService.submit(subCalc);
}
}
return getResult();
}
/**
* 迭代每个只任务，获得部分和，相加返回
* @return
*/
public Long getResult() {
Long result = 0l;
for (int i = 0; i < cpuCoreNumber; i++) {
try {
Long subSum = completionService.take().get();
result += subSum;
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
return result;
}
public void close() {
exec.shutdown();
}
}举例3：
package com.thread;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* http://www.linuxidc.com/Linux/2014-02/96879.htm
* Java1.5后的多线程框架
* @author liushuo
*/
public class CountDownLatchDemo {
private static final int PLAYER_AMOUNT = 5;
public CountDownLatchDemo() {
// TODO Auto-generated constructor stub
}
public void test() {
// 对于每位运动员，CountDownLatch减1后即结束比赛
CountDownLatch begin = new CountDownLatch(1);
// 对于整个比赛，所有运动员结束后才算结束
CountDownLatch end = new CountDownLatch(PLAYER_AMOUNT);
Player[] plays = new Player[PLAYER_AMOUNT];
for (int i = 0; i < PLAYER_AMOUNT; i++)
plays[i] = new Player(i + 1, begin, end);
// 设置特定的线程池，大小为5
ExecutorService exe = Executors.newFixedThreadPool(PLAYER_AMOUNT);
for (Player p : plays)
exe.execute(p); // 分配线程
System.out.println("Race begins!");
begin.countDown();
try {
end.await(); // 等待end状态变为0，即为比赛结束
} catch (InterruptedException e) {
// TODO: handle exception
e.printStackTrace();
} finally {
System.out.println("Race ends!");
}
exe.shutdown();
}
public class Player implements Runnable {
private int id;
private CountDownLatch begin;
private CountDownLatch end;
public Player(int i, CountDownLatch begin, CountDownLatch end) {
// TODO Auto-generated constructor stub
super();
this.id = i;
this.begin = begin;
this.end = end;
}
@Override
public void run() {
// TODO Auto-generated method stub
try {
begin.await(); // 等待begin的状态为0
Thread.sleep((long) (Math.random() * 100)); // 随机分配时间，即运动员完成时间
System.out.println("Play" + id + " arrived.");
} catch (InterruptedException e) {
// TODO: handle exception
e.printStackTrace();
} finally {
end.countDown(); // 使end状态减1，最终减至0
}
}
}
}
扫一扫
1144
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
