《利用CAS实现自旋锁》

1.自旋锁概念

• 自旋锁（spinlock）：是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。

2.编写自旋锁

import java.util.concurrent.atomic.AtomicBoolean;
//自旋锁
public class SpinLock {
    
    //CAS
    private AtomicBoolean cas = new AtomicBoolean(false);
    //锁持有者线程
    private Thread spinLockOwnerThread = null;

    public void lock(){
    

        while (!cas.compareAndSet(false,true))
        {
    
            //CAS自旋
        }
        spinLockOwnerThread = Thread.currentThread();
    }

    public void unLock(){
    
        //当前线程等于锁持有着线程才允许解锁
        if (Thread.currentThread()==spinLockOwnerThread)
        {
    
            spinLockOwnerThread = null;
            cas.set(false);
            //最后设置CAS的值为false，为什么？
            //如果先执行cas.set(false)，此时又来了一个新的线程，
            //成功过了CAS的compareAndSet，
            //将 spinLockOwnerThread 指向Thread.currentThread();
            //最后再执行spinLockOwnerThread = null;
            //这会导致最后持有锁的线程无法解锁
            //也就是无法通过Thread.currentThread()==spinLockOwnerThread判断
            //从而导致程序一直阻塞
           
        }
    }
}

3.测试自旋锁

class Test {
    
    //引入自旋锁
    private static final SpinLock spinLock = new SpinLock();

    public static void main(String[] args) {
    
        Thread t1  = new Thread(Test::run,"t1");
        Thread t2  = new Thread(Test::run,"t2");
        Thread t3  = new Thread(Test::run,"t3");
        Thread t4  = new Thread(Test::run,"t4");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

    public static void run(){
    
        spinLock.lock();
        System.out.println(Thread.currentThread().getName());
        try 
        {
    
            Thread.sleep(5000);
        } 
        catch (InterruptedException e) 
        {
    
            e.printStackTrace();
        }
        finally
        {
    
          spinLock.unLock();
        }
      
    }
}