前言

重入锁（ReentrantLock）是一种递归无阻塞的同步机制。
重入锁，也叫做递归锁，指的是同一线程外层函数获得锁之后，内层递归函数仍然有获取该锁的代码，但不受影响。
在JAVA环境下 ReentrantLock 和synchronized 都是可重入锁

举个例子-重入锁

从例子可以看出，如果同一个线程调用了两次lock方法，第一次lock时候锁定计数为1，第二次调用发现已经被锁定了，直接就返回1.

这就是重入锁，如果是自旋锁就不是这样，请看下面的例子

public class Test implements Runnable {

    public synchronized void get() {
        System.out.println(Thread.currentThread().getId());
        set();
    }


    public synchronized void set() {
        System.out.println(Thread.currentThread().getId());
    }


    @Override
    public void run() {
        get();
    }

    public static void main(String[] args) {
        Test ss = new Test();
        new Thread(ss).start();
        new Thread(ss).start();
        new Thread(ss).start();
    }


    class Test implements Runnable {
        ReentrantLock lock = new ReentrantLock();
        public void get() {
            lock.lock();
            System.out.println(Thread.currentThread().getId());
            set();
            lock.unlock();
        }


        public void set() {
            lock.lock();
            System.out.println(Thread.currentThread().getId());
            lock.unlock();
        }


        @Override

        public void run() {
            get();
        }


        public static void main(String[] args) {
            Test ss = new Test();
            new Thread(ss).start();
            new Thread(ss).start();
            new Thread(ss).start();
        }
    }
}

自旋锁

由于自旋锁使用者一般保持锁时间非常短，因此选择自旋而不是睡眠是非常必要的，自旋锁的效率远高于互斥锁。

如何旋转呢？何为自旋锁，就是如果发现锁定了，不是睡眠等待，而是采用让当前线程不停地的在循环体内执行实现的，当循环的条件被其他线程改变时才能进入临界区

代码演示如何自选

/**
 * @Package: com.example.lock
 * @Description: 自旋锁
 * @author: liuxin
 * @date: 2017/8/28 下午4:48
 */

public class SpinLock {

    //初始化为当前线程
    private AtomicReference<Thread> sign = new AtomicReference<>();

    public void lock() {

        Thread current = Thread.currentThread();
        //null 不等于当前线程，返回false   !fasle=true进入自选
        while (!sign.compareAndSet(null, current)) {

        }

    }

    public void unlock() {

        Thread current = Thread.currentThread();
        //对比current= 初始化信息，所以为true，并设置为null，此时
//        while (!sign.compareAndSet(null, current))，所以，null=null，lock中自旋结束，当一个锁完成，sign中有回到初始化状态。
        sign.compareAndSet(current, null);

    }

}

使用了CAS原子操作，lock函数将owner设置为当前线程，并且预测原来的值为空。unlock函数将owner设置为null，并且预测值为当前线程。

当有第二个线程调用lock操作时由于owner值不为空，导致循环一直被执行，直至第一个线程调用unlock函数将owner设置为null，第二个线程才能进入临界区。

由于自旋锁只是将当前线程不停地执行循环体，不进行线程状态的改变，所以响应速度更快。但当线程数不停增加时，性能下降明显，因为每个线程都需要执行，占用CPU时间。如果线程竞争不激烈，并且保持锁的时间段。适合使用自旋锁。