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

来源：互联网发布：旅游网络销售范围编辑：程序博客网时间：2024/05/16 04:40

笔记摘要：

这里首先介绍了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点的时间减去

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

[java] view plaincopy
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对象。

示例：

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

[java] view plaincopy
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();  
            }  
        }  
    }  
}  

0 0

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

笔记摘要：

一、java.util.concurrent.atomic包：

二、线程池：

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

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