重入锁和自旋锁(公平锁及非公平锁)

公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己
非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种方式

前言

重入锁（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时间。如果线程竞争不激烈，并且保持锁的时间段。适合使用自旋锁。

Lock常用API

Method	Explain
lock.getHoldCount()	查询当前线程报错此锁定的个数，也就是调用lock()的次数
lock.getQueueLength()	返回正等待获取此锁定的线程估计数，比如有5个线程，1个线程首先执行await（）方法，那么在调用getQueueLength（）方法后返回值是4，说明有4个线程同时在等待lock的释放。
lock.getWaitQueueLength(condition)	返回等待与此锁定相关的给定条件Condition的线程估计数，比如有5个线程，每个线程都执行了同一个condition对象的await（）方法，则调用getWaitQueueLength（Conditioncondition）方法时返回的int值是5。
lock.hasQueuedThread(thread)	查询指定的线程是否正在等待获取此锁定
lock.hasQueuedThreads()	查询是否有线程正在等待此锁定
lock.hasWaiters(condition)	是查询是否有线程正在等待与此锁定有关的condition条件
lock.isHeldByCurrentThread（）	查询当前线程是否保持此锁定
lock.isLocked（）	查询此锁定是否由任意线程保持
lock.lockInterruptibly()	如果当前线程未被中断，则获取锁定，如果已经被中断则出现异常
lock.tryLock()	仅在调用时锁定未被另一个线程保持的情况下，才获取该锁定
lock.tryLock(long timeout, TimeUnit unit)	方法booleantryLock（longtimeout，TimeUnitunit）的作用是，如果锁定在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁定