概述

自旋锁：spinlock，是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU 原来提到的比较并交换，底层使用的就是自旋，自旋就是多次尝试，多次访问，不会阻塞的状态就是自旋。

优缺点

优点：循环比较获取直到成功为止，没有类似于wait的阻塞 缺点：当不断自旋的线程越来越多的时候，会因为执行while循环不断的消耗CPU资源

手写自旋锁

  1. /**
  2.  * 手写一个自旋锁
  3.  *
  4.  * 循环比较获取直到成功为止，没有类似于wait的阻塞
  5.  *
  6.  * 通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒，B随后进来发现当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到
  7.  */
  8. public class SpinLockDemo {
  10.     // 现在的泛型装的是Thread，原子引用线程
  11.     AtomicReference<Thread> atomicReference = new AtomicReference<>();
  13.     public void myLock() {
  14.         // 获取当前进来的线程
  15.         Thread thread = Thread.currentThread();
  16.         System.out.println(Thread.currentThread().getName() + "\t come in ");
  18.         // 开始自旋，期望值是null，更新值是当前线程，如果是null，则更新为当前线程，否者自旋
  19.         while(!atomicReference.compareAndSet(null, thread)) {
  21.         }
  22.     }
  24.     /**
  25.      * 解锁
  26.      */
  27.     public void myUnLock() {
  29.         // 获取当前进来的线程
  30.         Thread thread = Thread.currentThread();
  32.         // 自己用完了后，把atomicReference变成null
  33.         atomicReference.compareAndSet(thread, null);
  35.         System.out.println(Thread.currentThread().getName() + "\t invoked myUnlock()");
  36.     }
  38.     public static void main(String[] args) {
  40.         SpinLockDemo spinLockDemo = new SpinLockDemo();
  42.         // 启动t1线程，开始操作
  43.         new Thread(() -> {
  45.             // 开始占有锁
  46.             spinLockDemo.myLock();
  48.             try {
  49.                 TimeUnit.SECONDS.sleep(5);
  50.                 System.out.println("---5秒后---");
  51.             } catch (InterruptedException e) {
  52.                 e.printStackTrace();
  53.             }
  55.             // 开始释放锁
  56.             spinLockDemo.myUnLock();
  58.         }, "t1").start();
  61.         // 让main线程暂停1秒，使得t1线程，先执行
  62.         try {
  63.             TimeUnit.SECONDS.sleep(1);
  64.             System.out.println("---1秒后---");
  65.         } catch (InterruptedException e) {
  66.             e.printStackTrace();
  67.         }
  69.         // 1秒后，启动t2线程，开始占用这个锁
  70.         new Thread(() -> {
  72.             // 开始占有锁
  73.             spinLockDemo.myLock();
  74.             // 开始释放锁
  75.             spinLockDemo.myUnLock();
  77.         }, "t2").start();
  79.     }
  80. }

运行结果

t1 come in —-1秒后—- t2 come in —-5秒后—- t1 invoked myUnlock() t2 invoked myUnlock()

结论

首先输出的是 t1 come in 然后1秒后，t2线程启动，发现锁被t1占有，所有不断的执行 compareAndSet方法，来进行比较，直到t1释放锁后，也就是5秒后，t2成功获取到锁，然后释放