java 自旋锁（可重入且无死锁）

java自旋锁 的实现原理：如果自旋锁被另外一个线程对象持有，那么当前获取锁的线程将陷入while循环等待，直到那个持有自旋锁的线程对象释放它所持有的自旋锁，那么那些想要获取该自旋锁的线程对象 将会有一个获得该自旋锁。

  基于他这种原理，等待的时候，并不释放cpu时间片，相比synchronized  wait()操作，减小了释放，重新获取的消耗。 该自旋锁适用于，当前线程竞争不强烈的时候使用。

代码：

[java]   view plain  copy

1. public class Test implements Runnable {  
2.     static int sum;  
3.     private SpinLock lock;  
4.       
5.     public Test(SpinLock lock) {  
6.         this.lock = lock;  
7.     }  
8.       
9.     /** 
10.      * @param args 
11.      * @throws InterruptedException  
12.      */  
13.     public static void main(String[] args) throws InterruptedException {  
14.         SpinLock lock = new SpinLock();  
15.         for (int i = 0; i < 100; i++) {  
16.             Test test = new Test(lock);  
17.             Thread t = new Thread(test);  
18.             t.start();  
19.         }  
20.           
21.         Thread.currentThread().sleep(1000);  
22.         System.out.println(sum);  
23.     }  
24.       
25.     @Override  
26.     public void run() {  
27.         this.lock.lock();  
28.         this.lock.lock();  
29.         sum++;  
30.         this.lock.unLock();  
31.         this.lock.unLock();  
32.     }  
33.   
34. }  

[java]   view plain  copy

1. <pre name="code" class="java">package optimiz_spinlock;  
2.   
3. import java.util.concurrent.atomic.AtomicReference;  
4.   
5. /** 
6.  * 可重入的自旋锁  (重新进入 不会出现死锁) 
7.  * @author Administrator 
8.  * 
9.  */  
10. public class SpinLock {  
11.     AtomicReference<Thread> owner = new AtomicReference<Thread>();//持有自旋锁的线程对象  
12.     private int count;//用一个计数器 来做 重入锁获取次数的计数  
13.     public void lock() {  
14.         Thread cur = Thread.currentThread();  
15.         if (cur == owner.get()) {  
16.             count++;  
17.             return;  
18.         }  
19.           
20.         while (!owner.compareAndSet(null, cur)) {//当线程越来越多  由于while循环 会浪费CPU时间片，CompareAndSet 需要多次对同一内存进行访问  
21.             //会造成内存的竞争，然而对于X86，会采取竞争内存总线的方式来访问内存，所以会造成内存访问速度下降(其他线程老访问缓存)，因而会影响整个系统的性能  
22.         }  
23.     }  
24.       
25.     public void unLock() {  
26.         Thread cur = Thread.currentThread();  
27.         if (cur == owner.get()) {  
28.             if (count > 0) {  
29.                 count--;  
30.             } else {  
31.                 owner.compareAndSet(cur, null);  
32.             }  
33.         }  
34.     }  
35. }  

为何说它是可重入的？我们接下来看一个不可重入的自旋锁（不可重入的自旋锁，如果再次去获取锁的话 很有可能出现死锁）。

不可重入的自旋锁的实现：

[java]   view plain  copy

1. package optimiz_spinlock;  
2.   
3. import java.util.concurrent.atomic.AtomicReference;  
4.   
5. public class BadSpinLock {  
6.   
7.     AtomicReference<Thread> owner = new AtomicReference<Thread>();//持有自旋锁的线程对象  
8.     public void lock() {  
9.         Thread cur = Thread.currentThread();  
10.         while (!owner.compareAndSet(null, cur)) {  
11.             System.out.println(cur.getName()+ " wait lock release");  
12.         }  
13.     }  
14.       
15.     public void unLock() {  
16.         Thread cur = Thread.currentThread();  
17.         if (cur == owner.get()) {  
18.             owner.compareAndSet(cur, null);  
19.             System.out.println(cur.getName()+ " release lock");  
20.         }  
21.     }  
22.   
23.   
24. }  

[java]   view plain  copy

1. package optimiz_spinlock;  
2.   
3. public class BadTestTask implements Runnable{  
4.     static int sum;  
5.     private BadSpinLock lock;  
6.       
7.     public BadTestTask(BadSpinLock lock) {  
8.         this.lock = lock;  
9.     }  
10.       
11.     /** 
12.      * @param args 
13.      * @throws InterruptedException  
14.      */  
15.     public static void main(String[] args) throws InterruptedException {  
16.         BadSpinLock lock = new BadSpinLock();  
17.         for (int i = 0; i < 2; i++) {  
18.             BadTestTask test = new BadTestTask(lock);  
19.             Thread t = new Thread(test);  
20.             t.start();  
21.         }  
22.           
23.     }  
24.       
25.     @Override  
26.     public void run() {  
27.         this.lock.lock();  
28.         this.lock.lock();  
29.         sum++;  
30.         this.lock.unLock();  
31.         this.lock.unLock();  
32.     }  
33.   
34. }  

当一个线程 调用这个不可重入的自旋锁去加锁的时候没问题，当再次调用lock()的时候，因为自旋锁的持有引用已经不为空了，该线程对象会误认为是别人的线程持有了自旋锁，我等我等！，等到地老天荒，哎呦妈啊，原来是自己拿着了，所以这是非常傻逼的问题。 出现这种问题的时候，持有自旋锁的那个线程不会释放该自旋锁，导致所有线程都会停留在while()循环里，后果不敢想了。

原文：http://blog.youkuaiyun.com/liushengbaoblog/article/details/39227863