多线程并发库高级应用 之 java5中的线程并发库--线程池、Callable&Future

笔记摘要：

这里首先介绍了java5中的并发的小工具包：automatic，然后介绍了线程池的概念，对使用java5的方式创建不同形式的线程进行了演示，

之后介绍了两个 对象：Callable和Future，用于获取线程执行后的结果，对于线程锁技术则在另外一篇文章中介绍。

Java5中的线程并发库都在java.util.concurrent包及子包中

一、java.util.concurrent.atomic包：

类的小工具包，支持在单个变量上解除锁的线程安全编程

1、如果同一个变量要被多个线程访问，则可以使用该包中的类：

AtomicBoolean、AtomicInteger、AtomicLong 和 AtomicReference

2、AtomicIntegerArray：操作数组里面的某个整数

3、同样该包中提供了可以用于反射操作的类：

AtomicReferenceFieldUpdater、

AtomicIntegerFieldUpdater 和 AtomicLongFieldUpdater

它们可以提供对关联字段类型的访问。

二、线程池：

在线程池的编程模式下，任务是提交给整个线程池，而不是直接交给某个线程，线程池在拿到任务后，它就在内部找有无空闲的线程，

再把任务交给内部某个空闲的线程，这就是封装。

记住：任务是提交给整个线程池，一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

示例：

创建固定大小的线程池、创建缓存线程池 、 用线程池创建定时器

创建单一线程池（始终保证线程池中会有一个线程在。当某线程死去，会找继任者）

注意:

定时器中总是相对时间，我们要想指定具体时间的方法：比如明天早上10点钟执行，则可以使用明天早上10点的时间减去

当前的时间，得到时间间隔

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {
public static void main(String[] args){

//创建固定大小的线程池，这里只能完成3个任务
//ExecutorService threadPool = Executors.newFixedThreadPool(3);

//创建缓存线程池，根据任务来自动创建线程的数量，可以完成创建的所有任务
//ExecutorService threadPool = Executors.newCachedThreadPool();

//创建单一线程池（始终保持线程池中有一个线程存活。当唯一线程死去，会创建新的继任者、
ExecutorService threadPool = Executors.newSingleThreadExecutor();

for(int i=1;i<=10;i++){
　　//内部类不能访问外部类的局部变量，所以i要定义为final，又由于i++.
　　//所以在循环内部定义一个变量接收i
final int task = i;
threadPool.execute(new Runnable() {

@Override
public void run() {
for(int j=1;j<=10;j++){
System.out.println(Thread.currentThread().getName()
+" is looping of "+ j+"  for task of " +task);
}

}
});
}
//验证10个任务都提交给了线程池
System.out.println("all of 10 tasks have committed! ");
//threadPool.shutdown();		//等任务完成后，杀死线程、
//threadPool.shutdownNow();		//立即停止线程

//用线程池启动定时器

Executors.newScheduledThreadPool(3).schedule(
new Runnable() {  //任务
@Override
public void run() {
System.out.println("bombing!");
}
},
5,	//5秒以后执行
TimeUnit.SECONDS);	//单位

//在某个时间执行一次后，再指定后续的执行间隔时间
Executors.newScheduledThreadPool(3).scheduleAtFixedRate(new Runnable(){

@Override
public void run() {
System.out.println("bombing!");
}

}, 10,   //第一次在10秒时爆炸
3,			//以后每隔3秒爆炸一次。
TimeUnit.SECONDS);

}
}

三、Callable & Future：用于获取线程执行完的结果

1、Callable 接口类似于Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，

并且无法抛出经过检查的异常，而Callable返回结果并且可能抛出异常的任务。

2、Future 接口表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能

使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。

3、Future取得的结果类型和Callable返回的结果类型必须一致，这是通过泛型来实现的。

Callable要采用ExecutorService的submit方法提交，返回的future对象可以取消任务、

4、CompletionService用于提交一组Callable任务，其take方法返回已完成的一个Callable任务对应的Future对象。

示例：

这里数据的获取好比同时种了号几块地的麦子，然后等待收割，秋收时，哪块先熟，先收割哪块。

import java.util.Random;
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;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CallableAndFuture {
public static void main(String[] args){

　　//创建一个单独的线程
　　ExecutorService threadPool = Executors.newSingleThreadExecutor();
　　//future泛型与Callable的类型一致
　　Future<String> future = threadPool.submit(new Callable<String>(){

@Override
public String call() throws Exception {
Thread.sleep(3000);
return "hello";
}

});
System.out.println("等待結果……");

//在指定时timeout内等待，未等到抛出TimeoutException
//System.out.println("拿到结果：" + future.get(long timeout,TimeUnit unit));

try {
System.out.println("拿到结果：" + future.get());	//获取线程执行后的结果

} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

//CompletionService用于提交一组Callable任务，
//其take方法返回已完成的一个Callable任务对应的Future对象。
ExecutorService threadPool2 = Executors.newFixedThreadPool(10);
CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPool2);

　　            //创建10任务
for(int i=1;i<=10;i++){
final int seq = i;

　　            //将任务提交给线程池
completionService.submit(new Callable<Integer>(){
@Override
public Integer call() throws Exception {
Thread.sleep(new Random().nextInt(5000));
return seq;
}
});
}
//获取结果，哪个结果先返回就先获得
for(int i=0;i<10;i++){
try {
System.out.println(completionService.take().get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
}