Java多线程之Semaphore，多线程semaphore

 

Java多线程之Semaphore

分类： [JAVA] [JAVA]--[并发编程]2011-12-21 09:49 4395人阅读 评论(0) 收藏 举报 semaphore多线程javastringclassservice [java] view plaincopyprint?

1. import java.util.ArrayList;  
2. import java.util.concurrent.ExecutorService;  
3. import java.util.concurrent.Executors;  
4. import java.util.concurrent.Semaphore;  
5. import java.util.concurrent.locks.Lock;  
6. import java.util.concurrent.locks.ReentrantLock;  
7.   
8. /** 
9.  * Java 5.0里新加了4个协调线程间进程的同步装置，它们分别是： 
10.  * Semaphore, CountDownLatch, CyclicBarrier和Exchanger. 
11.  * 本例主要介绍Semaphore。 
12.  * Semaphore是用来管理一个资源池的工具，可以看成是个通行证， 
13.  * 线程要想从资源池拿到资源必须先拿到通行证， 
14.  * 如果线程暂时拿不到通行证，线程就会被阻断进入等待状态。 
15.  */  
16. public class SemaphoreTest {  
17.     /** 
18.      * 模拟资源池的类 
19.      * 只为池发放2个通行证，即同时只允许2个线程获得池中的资源。 
20.      */  
21.     public static class Pool {  
22.         // 保存资源池中的资源  
23.         ArrayList<String> pool = null;  
24.         // 通行证  
25.         Semaphore pass = null;  
26.         Lock lock = new ReentrantLock();  
27.         public Pool(int size) {  
28.             // 初始化资源池  
29.             pool = new ArrayList<String>();  
30.             for (int i = 0; i < size; i++) {  
31.                 pool.add("Resource " + i);  
32.             }  
33.             // 发放2个通行证  
34.             pass = new Semaphore(2);  
35.         }  
36.   
37.         public String get() throws InterruptedException {  
38.             // 获取通行证,只有得到通行证后才能得到资源  
39.             System.out.println("Try to get a pass...");  
40.             pass.acquire();  
41.             System.out.println("Got a pass");  
42.             return getResource();  
43.         }  
44.   
45.         public void put(String resource) {  
46.             // 归还通行证，并归还资源  
47.             System.out.println("Released a pass");  
48.             pass.release();  
49.             releaseResource(resource);  
50.         }  
51.   
52.         private String getResource() {  
53.             lock.lock();  
54.             String result = pool.remove(0);  
55.             System.out.println("资源 " + result + " 被取走");  
56.             lock.unlock();  
57.             return result;  
58.         }  
59.   
60.         private void releaseResource(String resource) {  
61.             lock.lock();  
62.             System.out.println("资源 " + resource + " 被归还");  
63.             pool.add(resource);  
64.             lock.unlock();  
65.         }   
66.     }  
67.       
68.     public static void testPool() {  
69.         // 准备10个资源的资源池  
70.         final Pool aPool = new Pool(10);  
71.         Runnable worker = new Runnable() {  
72.             public void run() {  
73.                 String resource = null;  
74.                 try {  
75.                     //取得resource  
76.                     resource = aPool.get();  
77.                     //用resource做工作  
78.                     System.out.println("I am working on " + resource);  
79.                     Thread.sleep(500);  
80.                     System.out.println("I finished on " + resource);  
81.                 } catch (InterruptedException ex) {  
82.                 }  
83.                 //归还resource  
84.                 aPool.put(resource);  
85.             }  
86.         };  
87.         // 启动5个任务  
88.         ExecutorService service = Executors.newCachedThreadPool();  
89.         for (int i = 0; i < 5; i++) {  
90.             service.submit(worker);  
91.         }  
92.         service.shutdown();  
93.     }   
94.       
95.     public static void main(String[] args) {  
96.         SemaphoreTest.testPool();  
97.     }  
98. }