公平锁/非公平锁/可重入锁/自旋锁

在JAVA中我们知道有很多加锁的方式，比如常见的 通过synchronized关键字，还有Lock，还有之前说原子CAS操作时有看到过的死循环方式的自旋锁。

借此来说一下锁的分类:

公平锁:

是指多个线程按照申请的顺序来获取锁，每次获取锁时会先查看此锁维护的等待队列。先到先得。

非公平锁:

是指多个线程获取锁的顺序并不是按照申请锁的顺序，每个线程不停的去获取锁，直到成功，有可能后申请的线程比先申请的线程更先获取锁，高并发情况下，有可能造成优先级反转或者饥饿现象。

常见的非公平锁 synchronized/ReentrantLock(默认创建非公平锁new ReentrangLock(false/true))

不填默认就是false也可以 填写true使他变为公平锁。

可重入锁(递归锁):

synchronized/ReentrantLock都是可重入锁

线程可以进入任何一个他已经拥有的锁所同步着的代码块。

指的是同一线程外层函数获得锁之后，在进入内层方法会自动获取锁。可避免死锁

public synchronized method1(){
	method2();
}
public synchronized method2(){

}

复制

像这样的代码就表示了一个可重入锁。获取了method1方法的锁之后调用method2会自动获取锁。

看以下代码来确定以下是否是这样的。

这里我创建了两个线程A和B，每个线程调用method1方法，method1又调用了method2方法，method1和method2都加了锁，那么我们看一下运行结果，他们打印的线程名称是不是都是同一线程名。

可以看到结果在进入method2后获取锁的线程依然还是method1获取锁的那个线程，这就是可重入锁的表现。当然用上方代码块synchronized加锁的方式也可以达到可重入锁的效果，小伙伴们可以试一下。

自旋锁(spinlock):

是指尝试获取锁的线程不会立即进行阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少了线程之间的上下文切换消耗，缺点是循环会消耗CPU性能。

之前在说CAS操作时有提到过比较且交换这个点。那我们就根据他所提供的方法来自己写一个自旋锁，借此来复习一下之前的原子类操作知识点。

public class SpinLockDemo {
    /**
     * 之前有提到过AtomicReference这个原子类，它可以原子操作任何其他类，这里我们泛型里边写个Thread类
     * */
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void getLock() {
        // 获取当前执行此方法的线程
        Thread thread = Thread.currentThread();

        // 如果当前atomicReference内部值为null 则上锁，否则进入循环不停判断
        while (!atomicReference.compareAndSet(null, thread)) {
//            System.out.println("线程: " + thread.getName() + "尝试获取锁");
        }
        System.out.println("线程:\t" + thread.getName() + "\t进行加锁");
    }

    public void getUnLock() {
        // 获取当前执行此方法的线程
        Thread thread = Thread.currentThread();

        // 比较且将atomicReference内部值赋为null
        atomicReference.compareAndSet(thread, null);
        System.out.println("线程:\t" + thread.getName() + "释放了锁");
    }

    public static void main(String[] args) {

        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {
            spinLockDemo.getLock();

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            spinLockDemo.getUnLock();
        },"A").start();

        new Thread(() -> {
            spinLockDemo.getLock();
            spinLockDemo.getUnLock();
        },"B").start();


    }
}

复制

上边线程A先执行肯定先获取到了锁，然后休息3秒钟，咱们看执行结果是不是线程B在A释放锁之后

才能进行加锁。

我们可以看到线程B在A释放之后才成功的获取到了锁。

以上就是通过CAS原子操作实现的一个CAS自旋锁。