java1.5多线程_Java1.5后的多线程框架

内容主要包括之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

当我们向容器中提交多个任务时，建设我们提交任务的顺序是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：

/**

* 内核多线程求和，将数据划分成多个数据块，每个数据块交给一个cpu内核线程去计数和，最后在汇总所有数据的和

**/

public class ConcurrentCalculator {

private ExecutorService exec;

private CompletionService completionService;

private int cpuCoreNumber;

class SumCalculator implements Callable {

private int[] numbers;

private int start;

private int end;

public SumCalculator(final int[] numers, int start, int end) {

this.numbers = numbers;

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(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：

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

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

}

}

}

}