简述什么是 CAS 自旋锁

CAS

• CAS是compare and swap的缩写，译为比较并交换。
• CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。 如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值 。否则，处理器不做任何操作。
• 是CPU原语，java利用硬件提供的便利来提升系统的性能的一个典例。

自旋锁

持有锁的线程与等待竞争锁的线程不需要做内核态和用户态之间的切换进入阻塞状态，只需要循环等待持有锁的线程释放锁，从而避免了用户进程和内核切换的消耗。

因为自旋锁避免了操作系统进程调度和线程切换，所以自旋锁通常适用在时间比较短的情况下

CAS 自旋锁

用 CAS 自定义自旋锁并测试

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * CAS: 匹配的值是我所期望的值，则原来的值变为新的值
 * 案例体现： T1线程抢占到自旋锁之后，略过锁循环，T2线程却遇到了自旋锁循环，直到T1线程解锁，T2线程才能脱离循环
 * 本质：T1线程抢占锁之后改变了判断值（atomicReference），只有T1线程对象改变回原来的判断值（null）之后其他线程才允许不再自旋，所以不论其他任何的线程进来都无法摆脱自旋从而等待。
 **/
public class SpinlockDemo {
	// 原子方式更新对象引用（CAS）
    AtomicReference<Thread> atomicReference =
            new AtomicReference<>();

	// 加锁
    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName()
                + "==> mylock");
		// 自旋锁
        while (!atomicReference.compareAndSet(null, thread)) {
            try {
                TimeUnit.SECONDS.sleep(1L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("===");
        }
    }

	// 解锁
    public void myUnLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()
                + "==> myUnlock");
        atomicReference.compareAndSet(thread, null);
    }
}

// 测试
class TestSpinLock {

    public static void main(String[] args) throws
            InterruptedException {
            
        SpinlockDemo lock = new SpinlockDemo();
        // T1线程
        new Thread(() -> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(7);
                System.out.println("time out");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        }, "T1").start();
        
        // 睡眠保证 T1线程先执行
        TimeUnit.SECONDS.sleep(1);
        
        new Thread(() -> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println("time out");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }·
        }, "T2").start();
    }
}

执行结果

T1==> mylock
T2==> mylock
===
===
===
===
===
time out
T1==> myUnlock
===
time out
T2==> myUnlock

解释结果

// 一、T1 线程先执行加锁
// 二、!atomicReference.compareAndSet(null, thread) 为 false ，因为 V（判断值） 的初始值就是 null
// 三、退出while循环
T1==> mylock
// 一、T2 也希望加锁
// 二、!atomicReference.compareAndSet(null, thread) 为 true ， 因为 V（判断值） 已经更改为 T1 线程对象
// 三、不是程序期待的值，无法退出循环
T2==> mylock
// 开始自旋
===
===
===
===
===
// T1 线程执行结束
time out
// 一、T1 解锁 ， atomicReference.compareAndSet(thread, null);
// 二、V（判断值） 更改为 null
// 三、此时自旋锁内的 !atomicReference.compareAndSet(null, thread) 为 false 
T1==> myUnlock
===
// T2 加锁成功 ，摆脱自旋
// T2 线程执行结束
time out
// T2 线程解锁
T2==> myUnlock

文章说明

引用：

• 看完你就明白的锁系列之自旋锁
• Java中CAS详解