自旋锁一般有两个层面的理解。一个是程序层面的自旋，另一个是os级别的自旋。

程序层面的自旋

以java为例，一个很优秀的java级别的自旋锁就是ReentrantLock
源码层面实现自旋的代码片段

  1.     final boolean acquireQueued(final Node node, int arg) {
  2.         boolean failed = true;
  3.         try {
  4.             boolean interrupted = false;
  5.             for (;;) { //此处死循环
  6.                 final Node p = node.predecessor();
  7.                 if (p == head && tryAcquire(arg)) {//再次尝试加锁，
  8.                     setHead(node);
  9.                     p.next = null; // help GC
  10.                     failed = false;
  11.                     return interrupted;
  12.                 }
  13.                 if (shouldParkAfterFailedAcquire(p, node) &&
  14.                     parkAndCheckInterrupt())
  15.                     interrupted = true;
  16.             }
  17.         } finally {
  18.             if (failed)
  19.                 cancelAcquire(node);
  20.         }
  21.     }

此时的自旋锁，是处在JVM的层面的，并没有升级到内核态，所以此种自旋，相对于内核态的自旋效率更高。

spin lock

在linux系统中，系统提供了一个自旋锁方法，叫pthread_spin 调用了此方法实现自旋的已经升级到了内核态，CPU要实行上下文切换，效率低，耗资源