java多线程锁

foxsi

[Java]代码

1. package org.sky.threadpool;
   
2. 
   
3. import java.util.concurrent.ExecutorService;
   
4. import java.util.concurrent.Executors;
   
5. import java.util.concurrent.Future;
   
6. import java.util.concurrent.locks.Lock;
   
7. import java.util.concurrent.locks.ReadWriteLock;
   
8. import java.util.concurrent.locks.ReentrantLock;
   
9. import java.util.concurrent.locks.ReentrantReadWriteLock;
   
10. 
    
11. public class Lockers {
    
12. 
    
13.     public static class LockTest {
    
14.         Lock lock = new ReentrantLock();// 锁
    
15.         double value = 0d; // 值
    
16.         int addtimes = 0;
    
17. 
    
18.         /**
    
19.          * 增加value的值，该方法的操作分为2步，而且相互依赖，必须实现在一个事务中
    
20.          * 所以该方法必须同步，以前的做法是在方法声明中使用Synchronized关键字。
    
21.          */
    
22.         public void addValue(double v) {
    
23.             lock.lock();// 取得锁
    
24.             System.out.println("LockTest to addValue: " + v + "   "
    
25.                     + System.currentTimeMillis());
    
26.             try {
    
27.                 Thread.sleep(500);
    
28.             } catch (InterruptedException e) {
    
29.             }
    
30.             this.value += v;
    
31.             this.addtimes++;
    
32.             lock.unlock();// 释放锁
    
33.         }
    
34. 
    
35.         public double getValue() {
    
36.             return this.value;
    
37.         }
    
38.     }
    
39. 
    
40.     public static void testLockTest() throws Exception {
    
41.         final LockTest lockTest = new LockTest();
    
42.         // 新建任务1，调用lockTest的addValue方法
    
43.         Runnable task1 = new Runnable() {
    
44.             public void run() {
    
45.                 lockTest.addValue(1);
    
46.             }
    
47.         };
    
48.         // 新建任务2，调用lockTest的getValue方法
    
49.         Runnable task2 = new Runnable() {
    
50.             public void run() {
    
51.                 System.out.println("value: " + lockTest.getValue());
    
52.             }
    
53.         };
    
54.         // 新建任务执行服务
    
55.         ExecutorService cachedService = Executors.newCachedThreadPool();
    
56.         Future future = null;
    
57.         // 同时执行任务1三次，由于addValue方法使用了锁机制，所以，实质上会顺序执行
    
58.         for (int i = 0; i < 10; i++) {
    
59.             future = cachedService.submit(task1);
    
60.         }
    
61.         // 等待最后一个任务1被执行完
    
62.         future.get();
    
63.         // 再执行任务2，输出结果
    
64.         future = cachedService.submit(task2);
    
65.         // 等待任务2执行完后，关闭任务执行服务
    
66.         future.get();
    
67.         cachedService.shutdownNow();
    
68.     }
    
69.      
    
70.     /**
    
71.      * ReadWriteLock内置两个Lock，一个是读的Lock，一个是写的Lock。
    
72.      * 多个线程可同时得到读的Lock，但只有一个线程能得到写的Lock，
    
73.      * 而且写的Lock被锁定后，任何线程都不能得到Lock。ReadWriteLock提供的方法有：
    
74.      * readLock(): 返回一个读的lock  
    
75.      * writeLock(): 返回一个写的lock, 此lock是排他的。
    
76.      * ReadWriteLockTest很适合处理类似文件的读写操作。
    
77.      * 读的时候可以同时读，但不能写；写的时候既不能同时写也不能读。
    
78.      */
    
79.     public static class ReadWriteLockTest{  
    
80.         // 锁  
    
81.         ReadWriteLock lock = new ReentrantReadWriteLock();  
    
82.         // 值  
    
83.         double value = 0d;  
    
84.         int addtimes = 0;  
    
85.            
    
86.         /**
    
87.          * 增加value的值，不允许多个线程同时进入该方法
    
88.          */
    
89.         public void addValue(double v) {  
    
90.             // 得到writeLock并锁定  
    
91.             Lock writeLock = lock.writeLock();  
    
92.             writeLock.lock();  
    
93.             System.out.println("ReadWriteLockTest to addValue: " + v + "   "
    
94.                     + System.currentTimeMillis());  
    
95.             try {  
    
96.                 Thread.sleep(1000);  
    
97.             } catch (InterruptedException e) {  
    
98.             }  
    
99.             try {  
    
100.                 // 做写的工作  
     
101.                 this.value += v;  
     
102.                 this.addtimes++;  
     
103.             } finally {  
     
104.                 // 释放writeLock锁  
     
105.                 writeLock.unlock();  
     
106.             }  
     
107.         }  
     
108.         /**
     
109.          * 获得信息。当有线程在调用addValue方法时，getInfo得到的信息可能是不正确的。
     
110.          * 所以，也必须保证该方法在被调用时，没有方法在调用addValue方法。
     
111.          */
     
112.         public String getInfo() {  
     
113.             // 得到readLock并锁定  
     
114.             Lock readLock = lock.readLock();  
     
115.             readLock.lock();  
     
116.             System.out.println("ReadWriteLockTest to getInfo   "
     
117.                     + System.currentTimeMillis());  
     
118.             try {  
     
119.                 Thread.sleep(1000);  
     
120.             } catch (InterruptedException e) {  
     
121.             }  
     
122.             try {  
     
123.                 // 做读的工作  
     
124.                 return this.value + " : " + this.addtimes;  
     
125.             } finally {  
     
126.                 // 释放readLock  
     
127.                 readLock.unlock();  
     
128.             }  
     
129.         }  
     
130.     }  
     
131. 
     
132.     public static void testReadWriteLockTest() throws Exception {
     
133.         final ReadWriteLockTest readWriteLockTest = new ReadWriteLockTest();
     
134.         // 新建任务1，调用lockTest的addValue方法
     
135.         Runnable task_1 = new Runnable() {
     
136.             public void run() {
     
137.                 readWriteLockTest.addValue(55.55);
     
138.             }
     
139.         };
     
140.         // 新建任务2，调用lockTest的getValue方法
     
141.         Runnable task_2 = new Runnable() {
     
142.             public void run() {
     
143.                 System.out.println("info: " + readWriteLockTest.getInfo());
     
144.             }
     
145.         };
     
146.         // 新建任务执行服务
     
147.         ExecutorService cachedService_1 = Executors.newCachedThreadPool();
     
148.         Future future_1 = null;
     
149.         // 同时执行5个任务，其中前2个任务是task_1，后两个任务是task_2
     
150.         for (int i = 0; i < 2; i++) {
     
151.             future_1 = cachedService_1.submit(task_1);
     
152.         }
     
153.         for (int i = 0; i < 2; i++) {
     
154.             future_1 = cachedService_1.submit(task_2);
     
155.         }
     
156.         // 最后一个任务是task_1
     
157.         future_1 = cachedService_1.submit(task_1);
     
158.         // 这5个任务的执行顺序应该是：
     
159.         // 第一个task_1先执行，第二个task_1再执行；这是因为不能同时写，所以必须等。
     
160.         // 然后2个task_2同时执行；这是因为在写的时候，就不能读，所以都等待写结束，
     
161.         // 又因为可以同时读，所以它们同时执行
     
162.         // 最后一个task_1再执行。这是因为在读的时候，也不能写，所以必须等待读结束后，才能写。
     
163. 
     
164.         // 等待最后一个task_2被执行完
     
165.         future_1.get();
     
166.         cachedService_1.shutdownNow();
     
167.     }
     
168. 
     
169.     public static void main(String[] args) throws Exception {
     
170.         //Lockers.testLockTest();
     
171.         //System.out.println("---------------------");
     
172.         Lockers.testReadWriteLockTest();  
     
173.     }
     
174. }

复制代码