JDK 1.5 使用java.util.concurrent 开发并发应用

简单的并发应用

JDK 1.5 API 中增加了新的包.

java.util.concurrent 在并发编程中很常用的实用工具类。
java.util.concurrent.locks 为锁定和等待条件提供一个框架的接口和类，它不同于内置同步和监视器。

此包下的类图

常用的类 :

Executors 提供建立线程池或线程工厂的方法.

ExecutorService 提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。

Executor 可以简单理解为一个线程的执行者.

Future 表示异步计算的结果,对执行的线程的状态检查,可以获得执行结果.

FutureTask 此类提供了对 Future 的基本实现,可使用 FutureTask 包装Callable 或Runnable对象。所以可将 FutureTask 提交给Executor 执行。

Callable 线程要执行而去实现的接口

Semaphore 一个计数信号量,通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。

更加详细类说明和方法的应用,请可以查阅API

以下是简单的例子 :

(限制并发线程数量)

1. public static void main(String[]args){
2. //线程池
3. ExecutorServiceexec=Executors.newCachedThreadPool();
4. //只能5个线程同时访问
5. final Semaphoresemp= new Semaphore( 5 );
6. //模拟20个客户端访问
7. for ( int index= 0 ;index< 20 ;index++){
8. final int NO=index;
9. Runnablerun= new Runnable(){
10. public void run(){
11. try {
12. //获取许可
13. semp.acquire();
14. System.out.println( "thread:" +NO);
15. Thread.sleep(( long )(Math.random()* 1000 ));
16. //访问完后，释放
17. semp.release();
18. } catch (InterruptedExceptione){
19. }
20. }
21. };
22. exec.execute(run);
23. }
24. //退出线程池
25. exec.shutdown();
26. }

简单的线程池管理类:

1. import java.util.concurrent.Callable;
2. import java.util.concurrent.ExecutionException;
3. import java.util.concurrent.ExecutorService;
4. import java.util.concurrent.Executors;
5. import java.util.concurrent.Future;
6. import java.util.concurrent.FutureTask;
7. import java.util.concurrent.Semaphore;
8. /**
9. *线程池的管理类
10. *通过静态方法获得此类的实例
11. */
12. public class ThreadPoolManager<T>{
13. private ExecutorServiceservice= null ;
14. private final Semaphoresemp;
16. private int maxNum= 3 ;
18. private static ThreadPoolManagerme= null ;
19. public static ThreadPoolManagergetInstance(){
20. if (me== null ){
21. me= new ThreadPoolManager();
22. }
23. return me;
24. }
25. public static ThreadPoolManagergetInstance( int maxNum){
26. if (me== null ){
27. me= new ThreadPoolManager(maxNum);
28. }
29. return me;
30. }
31. private ThreadPoolManager(){
32. service=Executors.newCachedThreadPool();
33. semp= new Semaphore(maxNum);
34. }
35. private ThreadPoolManager( int maxNum){
36. this .maxNum=maxNum;
37. service=Executors.newCachedThreadPool();
38. semp= new Semaphore(maxNum);
39. }
41. /**
42. *执行线程任务,返回结果.
43. *如果线程池数量全部占用,则此线程阻塞.
44. *线程运行的传入参数类的实现方法.
45. *@paramtask实现java.util.concurrent.Callable接口的类
46. *@return返回线程运行的结果
47. *@throwsInterruptedException
48. *@throwsExecutionException
49. */
50. public TrunTask(Callable<T>task) throws InterruptedException,ExecutionException{
51. semp.acquire(); //使用信号标记,如果超过个数会造成线程阻塞
52. Future<T>f=service.submit(task); //加载线程任务,并且执行
53. semp.release(); //信号释放
54. return f.get(); //返回线程处理的结果,如果此线程尚未处理完成,则线程阻塞直到返回结果
55. }
57. /**
58. *@return返回线程可用数量
59. */
60. public synchronized int getavailableNum(){
61. return this .semp.availablePermits();
62. }
64. /**
65. *关闭线程池
66. */
67. public final void close(){
68. service.shutdown();
69. }
70. }
    

博文来源：http://ajava.org/course/java/12954.html