最简单高效的tryLock

Java代码  

1. import java.util.concurrent.atomic.AtomicBoolean;  
2.   
3. /** 
4.  * @author asme2u 
5.  */  
6. public class Lock {  
7.   
8.     private AtomicBoolean lock = new AtomicBoolean(true);  
9.   
10.     public boolean tryLock() {  
11.         return lock.compareAndSet(true, false);  
12.     }  
13.   
14.     public void unlock() {  
15.         lock.set(true);  
16.     }  
17.   
18. }  

 

原理：CAS

 

优点：

     速度快，约是ReentrantLock的2-3倍

 

 缺点：

     需JDK5.0+

     无条件对象且不可重入

     未获取锁时直接调用unlock不抛IllegalMonitorStateException所以代码必须严格保证获取锁后才能调用unlock

 

适用场景：

    不需要条件对象且当ReentrantLock的tryLock影响了你的性能的时候

 

我的应用场景：

    最近项目中通信程序中的客户端的socket长连接的连接池，客户端使用连接具有高并发但占用连接时间非常短的特点，使用这个类代替ReentrantLock，性能提高了3倍左右。

 

Java代码  

1. import java.util.concurrent.locks.ReentrantLock;  
2.   
3. /** 
4.  * @author asme2u 
5.  */  
6. public class TestLock {  
7.       
8.     private static long c = 0;  
9.     public static void main(String[] args) {  
10.         final Lock l = new Lock();  
11. //      final ReentrantLock l = new ReentrantLock();  
12.         Thread t1 = new Thread() {  
13.             public void run() {  
14.                 for (int i = 0; i < 100000000;) {  
15.                     if (l.tryLock()) {  
16.                         c++;  
17.                         i++;  
18.                         l.unlock();  
19.                     }  
20.                 }  
21.             }  
22.         };  
23.         Thread t2 = new Thread() {  
24.             public void run() {  
25.                 for (int i = 0; i < 100000000;) {  
26.                     if (l.tryLock()) {  
27.                         c++;  
28.                         i++;  
29.                         l.unlock();  
30.                     }  
31.                 }  
32.             }  
33.         };  
34.         long t = System.currentTimeMillis();  
35.         Thread t3 = new Thread() {  
36.             public void run() {  
37.                 for (int i = 0; i < 100000000;) {  
38.                     if (l.tryLock()) {  
39.                         c++;  
40.                         i++;  
41.                         l.unlock();  
42.                     }  
43.                 }  
44.             }  
45.         };  
46.         t1.start();  
47.         t2.start();  
48.         t3.start();  
49.         try {  
50.             t1.join();  
51.             t2.join();  
52.             t3.join();  
53.         } catch (InterruptedException e) {  
54.         }  
55.         System.out.println(c);  
56.         System.out.println(System.currentTimeMillis() - t);  
57.     }  
58. }