大家好，又见面了，我是你们的朋友全栈君。

一：悲观锁

 在Java中，synchronized和lock锁都是悲观锁。

定义：悲观锁认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改

 lock和synchronized是悲观锁，也是非公平锁。但是lock锁在new ReentrantLock(true); 参数状态为true的时候，他是公平锁。

class Number {
    
    //lock使用方法
    Lock lock = new ReentrantLock();
    public void getNumber() {
        try {
            lock.lock();
            //操作同步资源


        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //synchronized 使用方法
    public synchronized void getNumber1(){
        //操作同步资源
    }

}

二：乐观锁

定义：认为自己在使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有别的线程更新了这个数据。如果这个数据没有被更新，当前线程将自己修改的数据成功写入。如果数据已经被其他线程更新，则根据不同的实现方式执行不同的操作（例如报错或者自动重试）。乐观锁在Java中是通过使用无锁编程来实现，最常采用的是CAS算法，Java原子类中的递增操作就通过CAS自旋实现的。

public class VDemo01 {

    /**
     * Atomic  原子类
     * 为了保证原子性，不使用lock和synchronized
     * volatile 1实现了可见性，2上下 内存屏障，可以避免指令重拍 3不保证原子性
     */
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add() {
        num.getAndIncrement();//每次加一操作
        num.incrementAndGet();//每次加一操作
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {

                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "  " + num);
    }

}

CAS有着三大问题：

1. ABA问题。CAS需要在操作值的时候检查内存值是否发生变化，没有发生变化才会更新内存值。但是如果内存值原来是A，后来变成了B，然后又变成了A，那么CAS进行检查时会发现值没有发生变化，但是实际上是有变化的。ABA问题的解决思路就是在变量前面添加版本号，每次变量更新的时候都把版本号加一，这样变化过程就从“A－B－A”变成了“1A－2B－3A”。
   • JDK从1.5开始提供了AtomicStampedReference类来解决ABA问题，具体操作封装在compareAndSet()中。compareAndSet()首先检查当前引用和当前标志与预期引用和预期标志是否相等，如果都相等，则以原子方式将引用值和标志的值设置为给定的更新值。
2. 循环时间长开销大。CAS操作如果长时间不成功，会导致其一直自旋，给CPU带来非常大的开销。
3. 只能保证一个共享变量的原子操作。对一个共享变量执行操作时，CAS能够保证原子操作，但是对多个共享变量操作时，CAS是无法保证操作的原子性的。
   • Java从1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，可以把多个变量放在一个对象里来进行CAS操作。

三：自旋锁

定义：何谓自旋锁？它是为实现保护共享资源而提出一种锁机制。其实，自旋锁与互斥锁比较类似，它们都是为了解决对某项资源的互斥使用。无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。但是两者在调度机制上略有不同。对于互斥锁，如果资源已经被占用，资源申请者只能进入睡眠状态。但是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，”自旋”一词就是因此而得名。

 使用cas的原子性写一个demo

package com.example.springboot.controller.lock;

import java.util.concurrent.atomic.AtomicReference;

public class SpinLockDemo {

    AtomicReference<Thread> atomicReference =  new AtomicReference<>();

    //加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"mylock");
        //自旋锁
        while (!atomicReference.compareAndSet(null,thread)){
        }
    }

//解锁
    public void myUnLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"myUnLock");
        atomicReference.compareAndSet(thread,null);
    }
}

 public static void main(String[] args) {
        SpinLockDemo spinLock = new SpinLockDemo();

        new Thread(() -> {
            spinLock.myLock();
            try {

                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinLock.myUnLock();
            }

        }, "t1").start();

        new Thread(() -> {
            spinLock.myLock();
            try {

                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinLock.myUnLock();
            }

        }, "t2").start();
    }

自旋锁还分为：ticket Lock，CLH Lock，MCS Lock

四：无锁，偏向锁，轻量级锁，重量级锁

这四种锁都是形容的synchronized，目前锁一共有4种状态，级别从低到高依次是：无锁、偏向锁、轻量级锁和重量级锁。锁状态只能升级不能降级。

无锁：

无锁就是没有对对象进行锁定，所有的线程都可以去修改这个资源，但是只有一个线程可以成功，其他线程会一直重试，直到成功为止，CAS就是无锁的实现。

偏向锁：

偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁，降低获取锁的代价。

在大多数情况下，锁总是由同一线程多次获得，不存在多线程竞争，所以出现了偏向锁。其目标就是在只有一个线程执行同步代码块时能够提高性能。

当一个线程访问同步代码块并获取锁时，会在Mark Word里存储锁偏向的线程ID。在线程进入和退出同步块时不再通过CAS操作来加锁和解锁，而是检测Mark Word里是否存储着指向当前线程的偏向锁。引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径，因轻量级锁的获取及释放依赖多次CAS原子指令，而偏向锁只需要在置换ThreadID的时候依赖一次CAS原子指令即可。

偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程不会主动释放偏向锁。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有字节码正在执行），它会首先暂停拥有偏向锁的线程，判断锁对象是否处于被锁定状态。撤销偏向锁后恢复到无锁（标志位为“01”）或轻量级锁（标志位为“00”）的状态。

偏向锁在JDK 6及以后的JVM里是默认启用的。可以通过JVM参数关闭偏向锁：-XX:-UseBiasedLocking=false，关闭之后程序默认会进入轻量级锁状态。

轻量级锁：

是指当锁是偏向锁的时候，被另外的线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，从而提高性能。

在代码进入同步块的时候，如果同步对象锁状态为无锁状态（锁标志位为“01”状态，是否为偏向锁为“0”），虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的Mark Word的拷贝，然后拷贝对象头中的Mark Word复制到锁记录中。

拷贝成功后，虚拟机将使用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指针，并将Lock Record里的owner指针指向对象的Mark Word。

如果这个更新动作成功了，那么这个线程就拥有了该对象的锁，并且对象Mark Word的锁标志位设置为“00”，表示此对象处于轻量级锁定状态。

如果轻量级锁的更新操作失败了，虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧，如果是就说明当前线程已经拥有了这个对象的锁，那就可以直接进入同步块继续执行，否则说明多个线程竞争锁。

若当前只有一个等待线程，则该线程通过自旋进行等待。但是当自旋超过一定的次数，或者一个线程在持有锁，一个在自旋，又有第三个来访时，轻量级锁升级为重量级锁。

重量级锁：

升级为重量级锁时，锁标志的状态值变为“10”，此时Mark Word中存储的是指向重量级锁的指针，此时等待锁的线程都会进入阻塞状态。

总结：

偏向锁通过对比Mark Word解决加锁问题，避免执行CAS操作。而轻量级锁是通过用CAS操作和自旋来解决加锁问题，避免线程阻塞和唤醒而影响性能。重量级锁是将除了拥有锁的线程以外的线程都阻塞。

五：公平锁/非公平锁

公平锁：

公平锁是指多个线程按照申请锁的顺序来获取锁，线程都会进入队列中进行排队，只有队列中的第一个才能获取到锁，其他的线程都需要按照顺序来获取锁，等待队列中除第一个线程以外的所有线程都会阻塞，每当一个新的线程进行排队的时候，cpu的唤醒线程数则进行加一，CPU唤醒阻塞线程的开销比非公平锁大。下图举个例子。

 非公平锁：

非公平锁则是可以插队，比如在一个线程执行完的同时，在队列中等待的线程还没有进入，则插队的队列可以直接获取到锁，当然这个也是有两种情况，第一种是插队成功，直接获取到锁，避免了进入队列排队，如果插队成功的话，cpu需要唤醒的线程数是不变化的，第二种情况则是插队失败，线程进入队列中进行排队。在这种情况下，cpu需要唤醒的线程数则进行加一。下图举个例子。

以ReentrankLock为例子，他有一个内部类Sync，而Sync继承于AbstractQueuedSynchronizer，也就是AQS

 在公平锁和非公平锁的底层中可以看到，公平锁增加了hasQueuedPredecessors()。

 再进入hasQueuedPredecessors()，可以看到该方法主要做一件事情：主要是判断当前线程是否位于同步队列中的第一个。如果是则返回true，否则返回false。

六：可重入锁,非可重入锁

可重入锁：

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提锁对象得是同一个对象或者class），不会因为之前已经获取过还没释放而阻塞。Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。

下面代码可知，两个方法getLock1()和getLock2()都是synchronized修饰，在getLock1中调用getLock2（），因为内置锁是可重入的，所以同一个线程在调用getLock1()的时候，可以直接获取到当前对象的锁。从而直接进入getLock2()进行操作。

public class ReentrankLock {

    public static void main(String[] args) {

        ReentrankLock reentrankLock = new ReentrankLock();
        reentrankLock.getLock1();
    }

    public synchronized void getLock1() {
        System.out.println("lock1开始");
        getLock2();
        System.out.println("lock1结束");

    }

    public synchronized void getLock2() {
        System.out.println("lock2执行");
    }

}

图文说明：

非可重入锁：

和可重入锁相反，不可以递归调用，否则会死锁。

public class NoReentrankLock {

    MyLock lock = new MyLock();

    public static void main(String[] args) throws InterruptedException {
        new NoReentrankLock().doSomeThing(); 
    }
    public void doSomeThing() throws InterruptedException {
        lock.lock(); // 第一次上锁
        System.out.println("执行doJob方法前");
        doJob(); // 方法内会再次上锁
        lock.unlock(); // 释放第一次上的锁
    }
    public void doJob() throws InterruptedException {
        lock.lock();
        System.out.println("执行doJob方法过程中");
        lock.unlock();
    }



}
class MyLock{
    private boolean isLocked = false;
    public synchronized void lock() throws InterruptedException{
        while(isLocked){
            wait();
        }
        isLocked = true; // 线程第一次进入后就会将器设置为true，第二次进入是就会由于where true进入死循环
    }
    public synchronized void unlock(){
        isLocked = false;   // 将这个值设置为false目的是释放锁
        notify();           // 结束阻塞
    }
}

首先ReentrantLock和NonReentrantLock都继承父类AQS，其父类AQS中维护了一个同步状态status来计数重入次数，status初始值为0。

当线程尝试获取锁时，可重入锁先尝试获取并更新status值，如果status == 0表示没有其他线程在执行同步代码，则把status置为1，当前线程开始执行。如果status != 0，则判断当前线程是否是获取到这个锁的线程，如果是的话执行status+1，且当前线程可以再次获取锁。而非可重入锁是直接去获取并尝试更新当前status的值，如果status != 0的话会导致其获取锁失败，当前线程阻塞。

释放锁时，可重入锁同样先获取当前status的值，在当前线程是持有锁的线程的前提下。如果status-1 == 0，则表示当前线程所有重复获取锁的操作都已经执行完毕，然后该线程才会真正释放锁。而非可重入锁则是在确定当前线程是持有锁的线程之后，直接将status置为0，将锁释放。

七：共享锁，独享锁

共享锁：

共享锁是指该锁可被多个线程所持有。如果线程T对数据A加上共享锁后，则其他线程只能对A再加共享锁，不能加排它锁（独享锁）。获得共享锁的线程只能读数据，不能修改数据。

独享锁：

独享锁也叫排他锁，是指该锁一次只能被一个线程所持有。如果线程T对数据A加上排它锁后，则其他线程不能再对A加任何类型的锁。获得排它锁的线程即能读数据又能修改数据。JDK中的synchronized和JUC中Lock的实现类就是互斥锁。

我们看到ReentrantReadWriteLock有两把锁：ReadLock和WriteLock，由词知意，一个读锁一个写锁，合称“读写锁”。再进一步观察可以发现ReadLock和WriteLock是靠内部类Sync实现的锁。Sync是AQS的一个子类，这种结构在CountDownLatch、ReentrantLock、Semaphore里面也都存在。

在ReentrantReadWriteLock里面，读锁和写锁的锁主体都是Sync，但读锁和写锁的加锁方式不一样。读锁是共享锁，写锁是独享锁。读锁的共享锁可保证并发读非常高效，而读写、写读、写写的过程互斥，因为读锁和写锁是分离的。所以ReentrantReadWriteLock的并发性相比一般的互斥锁有了很大提升。

文中大部分图片以及知识来源于：不可不说的Java“锁”事 – 美团技术团队，感谢大佬写的博客。