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

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

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

代码：

public class Test implements Runnable {
	static int sum;
	private SpinLock lock;
	
	public Test(SpinLock lock) {
		this.lock = lock;
	}
	
	/**
	 * @param args
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException {
		SpinLock lock = new SpinLock();
		for (int i = 0; i < 100; i++) {
			Test test = new Test(lock);
			Thread t = new Thread(test);
			t.start();
		}
		
		Thread.currentThread().sleep(1000);
		System.out.println(sum);
	}
	
	@Override
	public void run() {
		this.lock.lock();
		this.lock.lock();
		sum++;
		this.lock.unLock();
		this.lock.unLock();
	}

}

package optimiz_spinlock;

import java.util.concurrent.atomic.AtomicReference;

/**
 * 可重入的自旋锁  (重新进入 不会出现死锁)
 * @author Administrator
 *
 */
public class SpinLock {
	AtomicReference owner = new AtomicReference();//持有自旋锁的线程对象
	private int count;//用一个计数器 来做 重入锁获取次数的计数
	public void lock() {
		Thread cur = Thread.currentThread();
		if (cur == owner.get()) {
			count++;
			return;
		}
		
		while (!owner.compareAndSet(null, cur)) {//当线程越来越多  由于while循环 会浪费CPU时间片，CompareAndSet 需要多次对同一内存进行访问
			//会造成内存的竞争，然而对于X86，会采取竞争内存总线的方式来访问内存，所以会造成内存访问速度下降(其他线程老访问缓存)，因而会影响整个系统的性能
		}
	}
	
	public void unLock() {
		Thread cur = Thread.currentThread();
		if (cur == owner.get()) {
			if (count > 0) {
				count--;
			} else {
				owner.compareAndSet(cur, null);
			}
		}
	}
}
 
  
 
  
 
  
 
  
为何说它是可重入的？我们接下来看一个不可重入的自旋锁（不可重入的自旋锁，如果再次去获取锁的话 很有可能出现死锁）。
 
  
不可重入的自旋锁的实现：
 
  
 
  
package optimiz_spinlock;

import java.util.concurrent.atomic.AtomicReference;

public class BadSpinLock {

	AtomicReference owner = new AtomicReference();//持有自旋锁的线程对象
	public void lock() {
		Thread cur = Thread.currentThread();
		while (!owner.compareAndSet(null, cur)) {
			System.out.println(cur.getName()+ " wait lock release");
		}
	}
	
	public void unLock() {
		Thread cur = Thread.currentThread();
		if (cur == owner.get()) {
			owner.compareAndSet(cur, null);
			System.out.println(cur.getName()+ " release lock");
		}
	}


}
 
  
 
  
package optimiz_spinlock;

public class BadTestTask implements Runnable{
	static int sum;
	private BadSpinLock lock;
	
	public BadTestTask(BadSpinLock lock) {
		this.lock = lock;
	}
	
	/**
	 * @param args
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException {
		BadSpinLock lock = new BadSpinLock();
		for (int i = 0; i < 2; i++) {
			BadTestTask test = new BadTestTask(lock);
			Thread t = new Thread(test);
			t.start();
		}
		
	}
	
	@Override
	public void run() {
		this.lock.lock();
		this.lock.lock();
		sum++;
		this.lock.unLock();
		this.lock.unLock();
	}

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