关键词：

锁机制的简单理解和使用

• 锁机制
• • 1、背景
  • 2、定义
  • 3、锁的种类
  • 4、乐观锁 VS 悲观锁
  • • 4.1、悲观锁
    • 4.2、乐观锁
    • 4.3、举例说明
    • 4.4、CAS算法
    • • 4.4.1、CAS使用
      • 4.4.2、CAS缺点
      • 4.4.3、总结
  • 5、自旋锁 VS 适应性自旋锁
  • • 5.1、自旋锁
    • 5.2、适应性自旋锁
    • 5.3、总结
  • 6、无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁
  • • 6.1、对象头
    • • 6.1.1、Mark Word
    • 6.2、Monitor
    • • 6.2.1、使用过程说明
    • 6.4、无锁
    • 6.5、偏向锁
    • 6.6、轻量级锁
    • 6.7、重量级锁
    • 6.8、总结
  • 7、公平锁 VS 非公平锁
  • • 7.1、公平锁
    • 7.2、非公平锁
    • 7.3、对比
    • 7.4、总结
  • 8、可重入锁 VS 非可重入锁
  • • 8.1、可重入锁
    • 8.2、不可重入锁
    • 8.3、对比
  • 9、独享锁 VS 共享锁
  • • 9.1、独享锁
    • 9.2、共享锁
  • 10、锁常见面试题
  • 参考

锁机制

1、背景

问题的产生：

• Java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据 的增删改查），将会导致数据不准确，相互之间产生冲突。

如下例：假设有一个卖票系统，一共有100张票，有4个窗口同时卖。

输出部分结果：

显然上述结果是不合理的，对于同一张票进行了多次售出。

这就是多线程情况下， 出现了数据“脏读”情况。

• 即多个线程访问余票num时，当一个线程获得余票的数 量，要在此基础上进行-1的操作之前，其他线程可能已经卖出多张票，导致获得的
  num不是最新的，然后-1后更新的数据就会有误。这就需要线程同步的实现了。

问题的解决：

因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证 了该变量的唯一性和准确性。

2、定义

在计算机科学中，锁(lock)或互斥(mutex)是一种同步机制，用于在有许多执行线程的环境中强制对资源的访问限制。锁旨在强制实施互斥排他、并发控制策略。

3、锁的种类

4、乐观锁 VS 悲观锁

乐观锁与悲观锁是一种广义上的概念，体现了看待线程同步的不同角度。在Java和数据库中都有此概念对应的实际应用。

4.1、悲观锁

对于同一个数据的并发操作，悲观锁认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改。

• Java 语言中 synchronized 和 ReentrantLock等就是典型的悲观锁
• 使用了 synchronized 关键字的容器类如 HashTable 等也是悲观锁的应用

举个生活中的例子，假设厕所只有一个坑位了，悲观锁上厕所会第一时间把门反锁上，这样其他人上厕所只能在门外等候，这种状态就是「阻塞」了。

回到代码世界中，一个共享数据加了悲观锁，那线程每次想操作这个数据前都会假设其他线程也可能会操作这个数据，所以每次操作前都会上锁，这样其他线程想操作这个数据拿不到锁只能阻塞了。

4.2、乐观锁

乐观锁认为自己在使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有别的线程更新了这个数据。

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

4.3、举例说明

// ------------------------- 悲观锁的调用方式 -------------------------
// synchronized
public synchronized void testMethod() 
	// 操作同步资源

// ReentrantLock
private ReentrantLock lock = new ReentrantLock(); // 需要保证多个线程使用的是同一个锁
public void modifyPublicResources() 
	lock.lock();
	// 操作同步资源
	lock.unlock();


// ------------------------- 乐观锁的调用方式 -------------------------
private AtomicInteger atomicInteger = new AtomicInteger();  // 需要保证多个线程使用的是同一个AtomicInteger
atomicInteger.incrementAndGet(); //执行自增1

通过调用方式示例，我们可以发现悲观锁基本都是在显式的锁定之后再操作同步资源，而乐观锁则直接去操作同步资源。

那么，为何乐观锁能够做到不锁定同步资源也可以正确的实现线程同步呢？我们通过介绍乐观锁的主要实现方式 “CAS” 的技术原理来为大家解惑。

4.4、CAS算法

CAS全称 Compare And Swap（比较与交换），是一种无锁算法。在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。

• java.util.concurrent包中的原子类就是通过CAS来实现了乐观锁。

CAS算法涉及到三个操作数：

• 需要读写的内存值 V。
• 进行比较的值 A。
• 要写入的新值 B。

当且仅当 V 的值等于 A 时，CAS通过原子方式用新值B来更新V的值（“比较+更新”整体是一个原子操作），否则不会执行任何操作。一般情况下，“更新”是一个不断重试的操作。

举例说明：

阿里二面，面试官：说说 Java CAS 原理？

CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，计算后要修改后的新值B。

• （1）初始状态：在内存地址V中存储着变量值为 1
  
• （2）线程1想要把内存地址为 V 的变量值增加1。这个时候对线程1来说，旧的预期值A=1，要修改的新值B=2。
  
• （3）在线程1要提交更新之前，线程2捷足先登了，已经把内存地址V中的变量值率先更新成了2。
  
• （4）线程1开始提交更新，首先将预期值A和内存地址V的实际值比较（Compare），发现A不等于V的实际值，提交失败。
  
• （5）线程1重新获取内存地址 V的当前值，并重新计算想要修改的新值。此时对线程1来说，A=2，B=3。这个重新尝试的过程被称为自旋。如果多次失败会有多次自旋。
  
• （6）线程 1 再次提交更新，这一次没有其他线程改变地址 V 的值。线程1进行Compare，发现预期值 A 和内存地址V的实际值是相等的，进行 Swap 操作，将内存地址 V 的实际值修改为 B。
  
• 总结：更新一个变量的时候，只有当变量的预期值 A 和内存地址 V 中的实际值相同时，才会将内存地址 V 对应的值修改为B，这整个操作就是CAS。

CAS 基本原理：

• CAS 主要包括两个操作：Compare和Swap，有人可能要问了：两个操作能保证是原子性吗？可以的。

CAS 是一种系统原语，原语属于操作系统用语，原语由若干指令组成，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说 CAS 是一条 CPU 的原子指令，由操作系统硬件来保证。

回到 Java 语言，JDK 是在 1.5 版本后才引入 CAS 操作，在sun.misc.Unsafe这个类中定义了 CAS 相关的方法。

public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);

public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);

public final native boolean compareAndSwapLong(Object o, long offset, long expected, long x);

4.4.1、CAS使用

目前 CAS 在 JDK 中主要应用在 J.U.C（java.util.concurrent） 包下的 Atomic 相关类中。

public static void main(String[] args) 
    //主内存中 atomicInteger 的初始值为 5
    AtomicInteger atomicInteger = new AtomicInteger(5);

    // 如果初始值是5，那么将初始值修改为1024，然后得修改后的值
    System.out.println(atomicInteger.compareAndSet(5, 1024) + "主内存中的最终值为: " + atomicInteger.get());

    System.out.println(atomicInteger.compareAndSet(5, 2048) + "主内存中的最终值为: " + atomicInteger.get());


/**
 * this：当前对象
 * valueOffSet：当前对象的内存地址偏移量，就是this的内存地址
*/
public final boolean compareAndSet(int expect, int update)    
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);

4.4.2、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带来非常大的开销。

• 解决方案：可以考虑限制自旋的次数，避免过度消耗 CPU；另外还可以考虑延迟执行。

3、只能保证一个共享变量的原子操作

• 当对一个共享变量执行操作时，可以使用 CAS 来保证原子性，但是如果要对多个共享变量进行操作时，CAS 是无法保证原子性的，比如需要将 i和 j 同时加 1：

i++；j++；

1、这个时候可以使用 synchronized 进行加锁

2、有没有其他办法呢？有，将多个变量操作合成一个变量操作。从 JDK1.5 开始提供了AtomicReference 类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。

4.4.3、总结

核心：compare and swap。需要3个操作数，分别是内存位置V，旧的预期值A，准备设置的新值B。CAS执行时，当地址V对应的旧值是A时，处理器才会将V对应的值更新为B，否则就不执行更新。该操作为原子操作，不会被其他线程中断；

Java的实现：引入Unsafe类，其通过本地native方法直接操作特定的内存数据。通过对内存的偏移地址去获取值和循环修改数据直至成功。JVM会编译成CAS的字节码指令，通过硬件功能保证指令执行过程中是连续的，原子性的。

5、自旋锁 VS 适应性自旋锁

为什么会出现自旋锁？

阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，这种状态转换需要耗费处理器时间。如果同步代码块中的内容过于简单，状态转换消耗的时间有可能比用户代码执行的时间还要长。

在许多场景中，同步资源的锁定时间很短，为了这一小段时间去切换线程，线程挂起和恢复现场的花费可能会让系统得不偿失。如果物理机器有多个处理器，能够让两个或以上的线程同时并行执行，我们就可以让后面那个请求锁的线程不放弃CPU的执行时间，看看持有锁的线程是否很快就会释放锁。

为了让当前线程“稍等一下”，我们需让当前线程进行自旋，如果在自旋完成后前面锁定同步资源的线程已经释放了锁，那么当前线程就可以不必阻塞而是直接获取同步资源，从而避免切换线程的开销。这就是自旋锁。

5.1、自旋锁

自旋锁是指线程在没有获得锁时不是被直接挂起，而是执行一个忙循环，这个忙循环就是所谓的自旋。

自旋锁本身是有缺点的，它不能代替阻塞。自旋等待虽然避免了线程切换的开销，但它要占用处理器时间。如果锁被占用的时间很短，自旋等待的效果就会非常好。

• 反之，如果锁被占用的时间很长，那么自旋的线程只会白浪费处理器资源。
• 所以，自旋等待的时间必须要有一定的限度，如果自旋超过了限定次数（默认是10次，可以使用-XX:PreBlockSpin来更改）没有成功获得锁，就应当挂起线程。

自旋锁的实现原理同样也是CAS，AtomicInteger中调用unsafe进行自增操作的源码中的do-while循环就是一个自旋操作，如果修改数值失败则通过循环来执行自旋，直至修改成功。

5.2、适应性自旋锁

自旋锁在JDK1.4.2中引入，使用-XX:+UseSpinning来开启。JDK 6中变为默认开启，并且引入了自适应的自旋锁（适应性自旋锁）。

自适应意味着自旋的时间（次数）不再固定，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。如果在同一个锁对象上，自旋等待刚刚成功获得过锁，并且持有锁的线程正在运行中，那么虚拟机就会认为这次自旋也是很有可能再次成功，进而它将允许自旋等待持续相对更长的时间。如果对于某个锁，自旋很少成功获得过，那在以后尝试获取这个锁时将可能省略掉自旋过程，直接阻塞线程，避免浪费处理器资源。

5.3、总结

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

6、无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁

6.1、对象头

Java对象保存在内存中时，由以下三部分组成：

1，对象头

2，实例数据: 对象的实例数据就是在java代码中能看到的属性和他们的值

3，对齐填充字节: 因为JVM要求java的对象占的内存大小应该是8bit的倍数，所以后面有几个字节用于把对象的大小补齐至8bit的倍数，没有特别的功能。

java的对象头由以下三部分组成：

1，Mark Word

2，指向类的指针:Java对象的类数据保存在方法区

3，数组长度（只有数组对象才有）: 该数据在32位和64位JVM中长度都是32bit

6.1.1、Mark Word

Java的对象头和对象组成详解

Mark Word记录了对象和锁有关的信息，当这个对象被synchronized关键字当成同步锁时，围绕这个锁的一系列操作都和Mark Word有关。

• Mark Word在32位JVM中的长度是32bit，在64位JVM中长度是64bit。
• Mark Word在不同的锁状态下存储的内容不同，在32位JVM中是这么存的：
  
  其中无锁和偏向锁的锁标志位都是01，只是在前面的1bit区分了这是无锁状态还是偏向锁状态。

JDK1.6以后的版本在处理同步锁时存在锁升级的概念，JVM对于同步锁的处理是从偏向锁开始的，随着竞争越来越激烈，处理方式从偏向锁升级到轻量级锁，最终升级到重量级锁。

JVM一般是这样使用锁和Mark Word的：

• 1、没有锁时，这就是一个普通的对象，Mark Word记录对象的HashCode，锁标志位是01，是否偏向锁那一位是0。
• 2、当对象被当做同步锁并有一个线程A抢到了锁时，锁标志位还是01，但是否偏向锁那一位改成1，前23bit记录抢到锁的线程id，表示进入偏向锁状态。
  • 当线程A再次试图来获得锁时，JVM发现同步锁对象的标志位是01，是否偏向锁是1，也就是偏向状态，MarkWord中记录的线程id就是线程A自己的id，表示线程A已经获得了这个偏向锁，可以执行同步锁的代码。
• 3、当线程B试图获得这个锁时，JVM发现同步锁处于偏向状态，但是Mark Word中的线程id记录的不是B，那么线程B会先用CAS操作试图获得锁，这里的获得锁操作是有可能成功的，因为线程A一般不会自动释放偏向锁。如果抢锁成功，就把Mark Word里的线程id改为线程B的id，代表线程B获得了这个偏向锁，可以执行同步锁代码。如果抢锁失败，则继续执行步骤4。
• 4、偏向锁状态抢锁失败，代表当前锁有一定的竞争，偏向锁将升级为轻量级锁。JVM会在当前线程的线程栈中开辟一块单独的空间，里面保存指向对象锁Mark Word的指针，同时在对象锁Mark Word中保存指向这片空间的指针。上述两个保存操作都是CAS操作，如果保存成功，代表线程抢到了同步锁，就把Mark Word中的锁标志位改成00，可以执行同步锁代码。如果保存失败，表示抢锁失败，竞争太激烈，继续执行步骤5。
• 5、轻量级锁抢锁失败，JVM会使用自旋锁，自旋锁不是一个锁状态，只是代表不断的重试，尝试抢锁。从JDK1.7开始，自旋锁默认启用，自旋次数由JVM决定。如果抢锁成功则执行同步锁代码，如果失败则继续执行步骤6。
• 6、自旋锁重试之后如果抢锁依然失败，同步锁会升级至重量级锁，锁标志位改为10。在这个状态下，未抢到锁的线程都会被阻塞。

6.2、Monitor

java monitor是什么意思,Java面试常见问题：Monitor对象是什么？

Monitor可以理解为一个同步工具或一种同步机制，通常被描述为一个对象。每一个Java对象就有一把看不见的锁，称为内部锁或者Monitor锁。

• Monitor是线程私有的数据结构，每一个线程都有一个可用monitor record列表，同时还有一个全局的可用列表。
• 每一个被锁住的对象都会和一个monitor关联，同时monitor中有一个Owner字段存放拥有该锁的线程的唯一标识，表示该锁被这个线程占用。
• 如果使用synchronized给对象加锁（重量级）之后，该对象的Mark Word就被设置指向了Monitor对象的指针

对象是如何跟monitor关联的呢？直接先看图：

Monitor结构：

6.2.1、使用过程说明

java对象结构与Monitor工作原理

• 1.首先如果一个线程要执行synchronized代码块，首先会尝试与Monitor对象进行关联（一个对象对应一个Monitor）
  

怎么进行关联呢？

原先对象头的状态是无锁，里面存储了hashcode等内容，现在需要将obj对象和Monitor对象关联，就要将Mark word里面的最开始无锁状态的hashcode，age都不要了，变成重量级锁，ptr_to_heavyweight_monitor指向Monitor地址，标志位由01变成10.

• 2.然后obj的Mark Word指向Monitor，线程指向Owner代表当前Monitor的主人是Thread-2
  
• 3.如果此时又有线程Thread1准备执行synchronized，发现MarkWord以及关联了一个Monitor，然后检查Owner有主人吗，发现Owner有主人，而且Owner只能有一个主人，然后这个线程Thread1只能进入EntryList（等待队列），进行等待!
  
• 4.如果线程2执行结束，释放掉锁，这时候Monitor中的Owner就没主人了，就看jdk底层实现调用EntryList中的其中一个线程去执行synchronized，去成为Monitor的主人
  

现在话题回到synchronized，synchronized通过Monitor来实现线程同步，Monitor是依赖于底层的操作系统的Mutex Lock（互斥锁）来实现的线程同步。

如同我们在自旋锁中提到的“阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，这种状态转换需要耗费处理器时间。如果同步代码块中的内容过于简单，状态转换消耗的时间有可能比用户代码执行的时间还要长”。

这种方式就是synchronized最初实现同步的方式，这就是JDK 6之前synchronized效率低的原因。这种依赖于操作系统Mutex Lock所实现的锁我们称之为“重量级锁”，JDK 6中为了减少获得锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁”。

所以目前锁一共有4种状态，级别从低到高依次是：

• 无锁、偏向锁、轻量级锁和重量级锁。
• 锁状态只能升级不能降级。

6.4、无锁

无锁没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功。

无锁的特点就是修改操作在循环内进行，线程会不断的尝试修改共享资源。如果没有冲突就修改成功并退出，否则就会继续循环尝试。如果有多个线程修改同一个值，必定会有一个线程能修改成功，而其他修改失败的线程会不断重试直到修改成功。上面我们介绍的CAS原理及应用即是无锁的实现。无锁无法全面代替有锁，但无锁在某些场合下的性能是非常高的。

6.5、偏向锁

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

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

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

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

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

6.6、轻量级锁

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

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

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

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

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

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

6.7、重量级锁

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

6.8、总结

整体的锁状态升级流程如下：

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

偏向锁、轻量级锁和重量级锁的区别？

• 偏向锁的优点是加解锁不需要额外消耗，和执行非同步方法比仅存在纳秒级差距，缺点是如果存在锁竞争会带来额外锁撤销的消耗，适用只有一个线程访问同步代码块的场景。
• 轻量级锁的优点是竞争线程不阻塞，程序响应速度快，缺点是如果线程始终得不到锁会自旋消耗 CPU，适用追求响应时间、同步代码块执行快的场景。
• 重量级锁的优点是线程竞争不使用自旋不消耗CPU，缺点是线程会阻塞，响应时间慢，适应追求吞吐量、同步代码块执行慢的场景。

7、公平锁 VS 非公平锁

7.1、公平锁

公平锁是指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。

• 公平锁的优点是等待锁的线程不会饿死。
• 缺点是整体吞吐效率相对非公平锁要低，等待队列中除第一个线程以外的所有线程都会阻塞，CPU唤醒阻塞线程的开销比非公平锁大。

7.2、非公平锁

非公平锁是多个线程加锁时直接尝试获取锁，获取不到才会到等待队列的队尾等待。但如果此时锁刚好可用，那么这个线程可以无需阻塞直接获取到锁，所以非公平锁有可能出现后申请锁的线程先获取锁的场景。

• 非公平锁的优点是可以减少唤起线程的开销，整体的吞吐效率高，因为线程有几率不阻塞直接获得锁，CPU不必唤醒所有线程。
• 缺点是处于等待队列中的线程可能会饿死，或者等很久才会获得锁。

7.3、对比

接下来我们通过ReentrantLock的源码来讲解公平锁和非公平锁。

根据代码可知，ReentrantLock里面有一个内部类Sync，Sync继承AQS（AbstractQueuedSynchronizer），添加锁和释放锁的大部分操作实际上都是在Sync中实现的。它有公平锁FairSync和非公平锁NonfairSync两个子类。ReentrantLock默认使用非公平锁，也可以通过构造器来显示的指定使用公平锁。

下面我们来看一下公平锁与非公平锁的加锁方法的源码:

通过上图中的源代码对比，我们可以明显的看出公平锁与非公平锁的lock()方法唯一的区别就在于公平锁在获取同步状态时多了一个限制条件：hasQueuedPredecessors()。

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

综上

• 公平锁就是通过同步队列来实现多个线程按照申请锁的顺序来获取锁，从而实现公平的特性。
• 非公平锁加锁时不考虑排队等待问题，直接尝试获取锁，所以存在后申请却先获得锁的情况。

7.4、总结

• 公平锁：在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果空，或者是队列首个就占有锁，否则就加入等待队列中，按照FIFO的规则获取锁；
• 非公平锁：先抢先得，否则就排队等待。 优点吞吐量大。synchronized也是非公平的。

8、可重入锁 VS 非可重入锁

8.1、可重入锁

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

• 可重入锁又称之为递归锁，是指同一个线程在外层方法获取了锁，在进入内层方法会自动获取锁。

Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。下面用示例代码来进行分析：

public class Widget 
    public synchronized void doSomething() 
        System.out.println("方法1执行...");
        doOthers();
    

    public synchronized void doOthers() 
        System.out.println("方法2执行...");
    

在上面的代码中，类中的两个方法都是被内置锁synchronized修饰的，doSomething()方法中调用doOthers()方法。因为内置锁是可重入的，所以同一个线程在调用doOthers()时可以直接获得当前对象的锁，进入doOthers()进行操作。

如果是一个不可重入锁，那么当前线程在调用doOthers()之前需要将执行doSomething()时获取当前对象的锁释放掉，实际上该对象锁已被当前线程所持有，且无法释放。所以此时会出现死锁。

而为什么可重入锁就可以在嵌套调用时可以自动获得锁呢？

我们通过图示和源码来分别解析一下。

还是打水的例子，有多个人在排队打水，此时管理员允许锁和同一个人的多个水桶绑定。这个人用多个水桶打水时，第一个水桶和锁绑定并打完水之后，第二个水桶也可以直接和锁绑定并开始打水，所有的水桶都打完水之后打水人才会将锁还给管理员。这个人的所有打水流程都能够成功执行，后续等待的人也能够打到水。这就是可重入锁。

8.2、不可重入锁

但如果是非可重入锁的话，此时管理员只允许锁和同一个人的一个水桶绑定。第一个水桶和锁绑定打完水之后并不会释放锁，导致第二个水桶不能和锁绑定也无法打水。当前线程出现死锁，整个等待队列中的所有线程都无法被唤醒。

8.3、对比

之前我们说过ReentrantLock和synchronized都是重入锁，那么我们通过重入锁ReentrantLock以及非可重入锁NonReentrantLock的源码来对比分析一下为什么非可重入锁在重复调用同步资源时会出现死锁。

首先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，将锁释放。

9、独享锁 VS 共享锁

独享锁 VS 共享锁

9.1、独享锁

独占锁是指锁一次只能被一个线程所持有。如果一个线程对数据加上排他锁后，那么其他线程不能再对该数据加任何类型的锁。获得独占锁的线程即能读数据又能修改数据。

• JDK中的synchronized和java.util.concurrent(JUC)包中Lock的实现类就是独占锁。

9.2、共享锁

共享锁是指锁可被多个线程所持有。如果一个线程对数据加上共享锁后，那么其他线程只能对数据再加共享锁，不能加独占锁。获得共享锁的线程只能读数据，不能修改数据。

• 在 JDK 中 ReentrantReadWriteLock 就是一种共享锁。

10、锁常见面试题

1、锁常见面试题
2、JAVA面试题|JAVA锁相关面试题总结
3、万字Java并发编程面试题（含答案，收藏版）

参考

1、Java线程安全与锁机制
2、不可不说的Java“锁”事
3、阿里面试失败后，一气之下我图解了Java中18把锁
4、一文看懂Java锁机制
5、一文看懂Java锁机制

java：数据结构笔记之lru缓存机制的简单理解和使用(代码片段)

JavaLRU缓存机制的简单理解和使用LRU缓存机制1、题目2、思路3、题解LRU缓存机制1、题目原题链接运用你所掌握的数据结构，设计和实现一个LRU(最近最少使用)缓存机制。它应该支持以下操作：获取数据get和写入数据put。获... 查看详情

java：java学习笔记之synchronized的简单理解和使用(代码片段)

JavaSynchronized的简单理解和使用Synchronized0、背景1、synchronized锁是什么？2、特点3、优点4、使用场景4.1.修饰实例方法:4.2.修饰静态方法:4.3.修饰代码块:4.4、注意4.5、双重校验锁实现对象单例（线程安全）4.6、总结5、底... 查看详情

java：java学习笔记之java单例模式的简单理解和使用(代码片段)

Java单例模式的简单理解和使用Java单例模式1、饿汉式单例的实现如下：2、懒汉式终极版本：volatile3、EffectiveJava1——静态内部类4、5.2EffectiveJava2——枚举参考Java单例模式1、饿汉式单例的实现如下：//饿汉式实现publiccl... 查看详情

android：安卓学习笔记之binder机制的简单理解和使用(代码片段)

Binder机制的简单理解和使用Binder机制1、背景1.1、进程空间划分1.2、进程隔离&跨进程通信（IPC）2、Binder到底是什么？3、Binder跨进程通信机制模型3.1、模型原理图3.1.1、模型拓展3.2、模型组成角色说明3.3、Binder驱动3.... 查看详情

java：java学习笔记之reentrantlock的简单理解和使用(代码片段)

ReentrantLockReentrantLock1、相关知识1.1公平锁和非公平锁1.2可重入锁1.3、CAS算法2、背景、定义和特征2.1、背景2.2、定义2.3、特征3、基本结构4、基本使用4.1、解决背景问题4.2、重入锁使用4.3、公平锁使用4.4、可中断使用4.5、可限时使... 查看详情

java：java学习笔记之枚举的简单理解和使用(代码片段)

Java枚举的简单理解和使用枚举的简单理解和使用1、背景2、定义3、使用4、常用内置方法：总结枚举的简单理解和使用1、背景在枚举出现之前，如果想要表示一组特定的离散值，往往使用一些常量。例如：publicclas... 查看详情

java：java学习笔记之reentrantlock的简单理解和使用(代码片段)

...ock和Synchronized对比7、总结参考ReentrantLock1、相关知识轻松学习java可重入锁(ReentrantLock)的实现原理1.1公平锁和非公平锁1）公平锁：多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列... 查看详情

java学习笔记之内部类和静态内部类的简单理解和使用(代码片段)

Java内部类和静态内部类内部类和静态内部类区别参考内部类和静态内部类区别简单理解就是：如果把类比喻成鸡蛋，内部类为蛋黄,外部类是蛋壳。那么静态类相当于熟鸡蛋，就算蛋壳破碎（外部类没有实例化ÿ... 查看详情

android：安卓学习笔记之handler机制的简单理解和使用(代码片段)

AndroidHandler机制的简单理解和使用Handler机制1、Handler使用的引出2、背景和定义3、作用和意义4、主要参数5、工作原理及流程5.1、对应关系6、深入分析Handler机制源码6.1、Handler机制的核心类6.2、核心方法6.3、方式1：使用Handler.s... 查看详情

java并发之锁的使用浅析

    锁像synchronized同步块一样，是一种线程同步机制。让自Java5开始，java.util.concurrent.locks包提供了另一种方式实现线程同步机制——Lock。那么问题来了既然都可以通过synchronized来实现同步访问了，那么为什... 查看详情

java学习注解和反射超详细笔记(代码片段)

目录一、注解1、注解入门2、内置注解3、自定义注解,元注解二、反射机制1、Java反射机制概念1.1静态&动态语言1.2反射机制概念1.3反射机制研究与应用1.4反射机制优缺点1.5实现2、理解Class类并获取Class实例2.1class类介绍2.2获取Cla... 查看详情

volatile学习笔记(代码片段)

全面理解Java内存模型(JMM)及volatile关键字正确使用Volatile变量Java内存模型在并发编程中，需要处理两个关键问题：线程之间如何通信及线程之间如何同步。通信是指线程之间以何种机制来交换信息。同步是指程序中用于控制不同... 查看详情

java讲课笔记36：初探反射机制

文章目录零、本讲学习目标一、认识反射（一）Java反射机制（二）Java反射的动态性质（三）如何理解Java反射的原理（四）利用反射可实现的功能二、Java反射常用API三、使用反射的基本步骤四、利用反射获取类的信息（一）获... 查看详情

深入理解jvm学习笔记——-7虚拟机类加载机制★

你只管努力，——剩下的交给时光。在Java语言中，类型的加载、连接和初始化都是在程序运行期间完成的。我们写的java文件是不能直接运行的，可以在IDE中右键文件名点击运行，这中间其实掺杂了一系列的复杂... 查看详情

java异常机制学习笔记一

什么是异常？　　异常，不正常也。Exception是Exception event的缩写，因此异常是一个事件，该事件发生在程序运行时。异常会影响程序的连续性，使程序中断。　　在Java中，一切皆对象，所以要定义异常，也需要使用对象。异... 查看详情

简单理解java反射机制

JAVA反射机制：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能给调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为JAVA语言的反射机制。这... 查看详情

android：安卓学习笔记之共享元素的简单理解和使用(代码片段)

Android共享元素的简单理解和使用1、基本概念2、基本使用1、ActivitytoActivity跳转实现1.1、使用步骤1.2、案例说明2、FragmenttoFragment跳转实现2.1、使用步骤2.2、案例说明3、Navigation+共享元素+recyclerview跳转实现3.1、使用步骤3.2、... 查看详情

android：安卓学习笔记之共享元素的简单理解和使用(代码片段)

Android共享元素的简单理解和使用1、基本概念2、基本使用1、ActivitytoActivity跳转实现1.1、使用步骤1.2、案例说明2、FragmenttoFragment跳转实现2.1、使用步骤2.2、案例说明3、Navigation+共享元素+recyclerview跳转实现3.1、使用步骤3.2、... 查看详情