java面试题(十三)之多线程篇

超、凢脫俗 2024-03-27 13:58 53阅读 0赞

## 4.11 如何实现子线程先执行，主线程再执行？ ##

**参考答案**

启动子线程后，立即调用该线程的join()方法，则主线程必须等待子线程执行完成后再执行。

**扩展阅读**

Thread类提供了让一个线程等待另一个线程完成的方法——join()方法。当在某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到被join()方法加入的join线程执行完为止。

join()方法通常由使用线程的程序调用，以将大问题划分成许多小问题，每个小问题分配一个线程。当所有的小问题都得到处理后，再调用主线程来进一步操作。

## 4.12 阻塞线程的方式有哪些？ ##

**参考答案**

当发生如下情况时，线程将会进入阻塞状态：

*  线程调用sleep()方法主动放弃所占用的处理器资源；
 *  线程调用了一个阻塞式IO方法，在该方法返回之前，该线程被阻塞；
 *  线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有；
 *  线程在等待某个通知（notify）；
 *  程序调用了线程的suspend()方法将该线程挂起，但这个方法容易导致死锁，所以应该尽量避免使用该方法。

## 4.13 说一说synchronized与Lock的区别 ##

**参考答案**

1.  synchronized是Java关键字，在JVM层面实现加锁和解锁；Lock是一个接口，在代码层面实现加锁和解锁。
2.  synchronized可以用在代码块上、方法上；Lock只能写在代码里。
3.  synchronized在代码执行完或出现异常时自动释放锁；Lock不会自动释放锁，需要在finally中显示释放锁。
4.  synchronized会导致线程拿不到锁一直等待；Lock可以设置获取锁失败的超时时间。
5.  synchronized无法得知是否获取锁成功；Lock则可以通过tryLock得知加锁是否成功。
6.  synchronized锁可重入、不可中断、非公平；Lock锁可重入、可中断、可公平/不公平，并可以细分读写锁以提高效率。

## 4.14 说一说synchronized的底层实现原理 ##

**参考答案**

一、synchronized作用在代码块时，它的底层是通过monitorenter、monitorexit指令来实现的。

*  monitorenter：每个对象都是一个监视器锁（monitor），当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1。如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。
 *  monitorexit：执行monitorexit的线程必须是objectref所对应的monitor持有者。指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个monitor的所有权。monitorexit指令出现了两次，第1次为同步正常退出释放锁，第2次为发生异步退出释放锁。

二、方法的同步并没有通过 monitorenter 和 monitorexit 指令来完成，不过相对于普通方法，其常量池中多了 ACC\_SYNCHRONIZED 标示符。JVM就是根据该标示符来实现方法的同步的：

当方法调用时，调用指令将会检查方法的 ACC\_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象。

三、总结

两种同步方式本质上没有区别，只是方法的同步是一种隐式的方式来实现，无需通过字节码来完成。两个指令的执行是JVM通过调用操作系统的互斥原语mutex来实现，被阻塞的线程会被挂起、等待重新调度，会导致“用户态和内核态”两个态之间来回切换，对性能有较大影响。

## 4.15 synchronized可以修饰静态方法和静态代码块吗？ ##

**参考答案**

synchronized可以修饰静态方法，但不能修饰静态代码块。

当修饰静态方法时，监视器锁（monitor）便是对象的Class实例，因为Class数据存在于永久代，因此静态方法锁相当于该类的一个全局锁。

## 4.16 谈谈ReentrantLock的实现原理 ##

**参考答案**

ReentrantLock是基于AQS实现的，AQS即AbstractQueuedSynchronizer的缩写，这个是个内部实现了两个队列的抽象类，分别是同步队列和条件队列。其中同步队列是一个双向链表，里面储存的是处于等待状态的线程，正在排队等待唤醒去获取锁，而条件队列是一个单向链表，里面储存的也是处于等待状态的线程，只不过这些线程唤醒的结果是加入到了同步队列的队尾，AQS所做的就是管理这两个队列里面线程之间的等待状态-唤醒的工作。

在同步队列中，还存在2中模式，分别是独占模式和共享模式，这两种模式的区别就在于AQS在唤醒线程节点的时候是不是传递唤醒，这两种模式分别对应独占锁和共享锁。

AQS是一个抽象类，所以不能直接实例化，当我们需要实现一个自定义锁的时候可以去继承AQS然后重写获取锁的方式和释放锁的方式还有管理state，而ReentrantLock就是通过重写了AQS的tryAcquire和tryRelease方法实现的lock和unlock。

ReentrantLock 结构如下图所示：

![19a5e9042eb8b2654f821cc39792825c.png][]

首先ReentrantLock 实现了 Lock 接口，然后有3个内部类，其中Sync内部类继承自AQS，另外的两个内部类继承自Sync，这两个类分别是用来公平锁和非公平锁的。通过Sync重写的方法tryAcquire、tryRelease可以知道，ReentrantLock实现的是AQS的独占模式，也就是独占锁，这个锁是悲观锁。

## 4.17 如果不使用synchronized和Lock，如何保证线程安全？ ##

**参考答案**

1.  volatile

volatile关键字为域变量的访问提供了一种免锁机制，使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新，因此每次使用该域就要重新计算，而不是使用寄存器中的值。需要注意的是，volatile不会提供任何原子操作，它也不能用来修饰final类型的变量。

1.  原子变量在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，使用该类可以简化线程同步。例如AtomicInteger 表可以用原子方式更新int的值，可用在应用程序中（如以原子方式增加的计数器），但不能用于替换Integer。可扩展Number，允许那些处理机遇数字类的工具和实用工具进行统一访问。
2.  本地存储可以通过ThreadLocal类来实现线程本地存储的功能。每一个线程的Thread对象中都有一个ThreadLocalMap对象，这个对象存储了一组以ThreadLocal.threadLocalHashCode为键，以本地线程变量为值的K-V值对，ThreadLocal对象就是当前线程的ThreadLocalMap的访问入口，每一个ThreadLocal对象都包含了一个独一无二的threadLocalHashCode值，使用这个值就可以在线程K-V值对中找回对应的本地线程变量。
3.  不可变的只要一个不可变的对象被正确地构建出来，那其外部的可见状态永远都不会改变，永远都不会看到它在多个线程之中处于不一致的状态，“不可变”带来的安全性是最直接、最纯粹的。Java语言中，如果多线程共享的数据是一个基本数据类型，那么只要在定义时使用final关键字修饰它就可以保证它是不可变的。如果共享数据是一个对象，由于Java语言目前暂时还没有提供值类型的支持，那就需要对象自行保证其行为不会对其状态产生任何影响才行。String类是一个典型的不可变类，可以参考它设计一个不可变类。

## 4.18 说一说Java中乐观锁和悲观锁的区别 ##

**参考答案**

悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。Java中悲观锁是通过synchronized关键字或Lock接口来实现的。

乐观锁：顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据。乐观锁适用于多读的应用类型，这样可以提高吞吐量。在JDK1.5 中新增 java.util.concurrent (J.U.C)就是建立在CAS之上的。相对于对于 synchronized 这种阻塞算法，CAS是非阻塞算法的一种常见实现。所以J.U.C在性能上有了很大的提升。

## 4.19 公平锁与非公平锁是怎么实现的？ ##

**参考答案**

在Java中实现锁的方式有两种，一种是使用Java自带的关键字synchronized对相应的类或者方法以及代码块进行加锁，另一种是ReentrantLock，前者只能是非公平锁，而后者是默认非公平但可实现公平的一把锁。

ReentrantLock是基于其内部类FairSync(公平锁)和NonFairSync(非公平锁)实现的，并且它的实现依赖于Java同步器框架AbstractQueuedSynchronizer（AQS），AQS使用一个整形的volatile变量state来维护同步状态，这个volatile变量是实现ReentrantLock的关键。我们来看一下ReentrantLock的类图：

![aa3cbf42fc7d20f636d12604210edf9b.jpeg][]

ReentrantLock 的公平锁和非公平锁都委托了 AbstractQueuedSynchronizer\#acquire 去请求获取。

public final void acquire(int arg) \{ if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); \}

*  tryAcquire 是一个抽象方法，是公平与非公平的实现原理所在。
 *  addWaiter 是将当前线程结点加入等待队列之中。公平锁在锁释放后会严格按照等到队列去取后续值，而非公平锁在对于新晋线程有很大优势。
 *  acquireQueued 在多次循环中尝试获取到锁或者将当前线程阻塞。
 *  selfInterrupt 如果线程在阻塞期间发生了中断，调用 Thread.currentThread().interrupt() 中断当前线程。

公平锁和非公平锁在说的获取上都使用到了 volatile 关键字修饰的state字段， 这是保证多线程环境下锁的获取与否的核心。但是当并发情况下多个线程都读取到 state == 0时，则必须用到CAS技术，一门CPU的原子锁技术，可通过CPU对共享变量加锁的形式，实现数据变更的原子操作。volatile 和 CAS的结合是并发抢占的关键。

*  公平锁FairSync公平锁的实现机理在于每次有线程来抢占锁的时候，都会检查一遍有没有等待队列，如果有， 当前线程会执行如下步骤：if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) \{ setExclusiveOwnerThread(current); return true; \}其中hasQueuedPredecessors是用于检查是否有等待队列的：public final boolean hasQueuedPredecessors() \{ Node t = tail; // Read fields in reverse initialization order Node h = head; Node s; return h != t && ((s = h.next) == null || s.thread != Thread.currentThread()); \}
 *  非公平锁NonfairSync非公平锁在实现的时候多次强调随机抢占：if (c == 0) \{ if (compareAndSetState(0, acquires)) \{ setExclusiveOwnerThread(current); return true; \} \} 与公平锁的区别在于新晋获取锁的进程会有多次机会去抢占锁，被加入了等待队列后则跟公平锁没有区别。

## 4.20 了解Java中的锁升级吗？ ##

**参考答案**

JDK 1.6之前，synchronized 还是一个重量级锁，是一个效率比较低下的锁。但是在JDK 1.6后，JVM为了提高锁的获取与释放效率对synchronized 进行了优化，引入了偏向锁和轻量级锁 ，从此以后锁的状态就有了四种：无锁、偏向锁、轻量级锁、重量级锁。并且四种状态会随着竞争的情况逐渐升级，而且是不可逆的过程，即不可降级，这四种锁的级别由低到高依次是：无锁、偏向锁，轻量级锁，重量级锁。如下图所示：

![c80eabef7483fc3c6acbfd6172df65b5.png][]

1.  无锁无锁是指没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功。无锁的特点是修改操作会在循环内进行，线程会不断的尝试修改共享资源。如果没有冲突就修改成功并退出，否则就会继续循环尝试。如果有多个线程修改同一个值，必定会有一个线程能修改成功，而其他修改失败的线程会不断重试直到修改成功。
2.  偏向锁初次执行到synchronized代码块的时候，锁对象变成偏向锁（通过CAS修改对象头里的锁标志位），字面意思是“偏向于第一个获得它的线程”的锁。执行完同步代码块后，线程并不会主动释放偏向锁。当第二次到达同步代码块时，线程会判断此时持有锁的线程是否就是自己（持有锁的线程ID也在对象头里），如果是则正常往下执行。由于之前没有释放锁，这里也就不需要重新加锁。如果自始至终使用锁的线程只有一个，很明显偏向锁几乎没有额外开销，性能极高。偏向锁是指当一段同步代码一直被同一个线程所访问时，即不存在多个线程的竞争时，那么该线程在后续访问时便会自动获得锁，从而降低获取锁带来的消耗，即提高性能。当一个线程访问同步代码块并获取锁时，会在 Mark Word 里存储锁偏向的线程 ID。在线程进入和退出同步块时不再通过 CAS 操作来加锁和解锁，而是检测 Mark Word 里是否存储着指向当前线程的偏向锁。轻量级锁的获取及释放依赖多次 CAS 原子指令，而偏向锁只需要在置换 ThreadID 的时候依赖一次 CAS 原子指令即可。偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程是不会主动释放偏向锁的。关于偏向锁的撤销，需要等待全局安全点，即在某个时间点上没有字节码正在执行时，它会先暂停拥有偏向锁的线程，然后判断锁对象是否处于被锁定状态。如果线程不处于活动状态，则将对象头设置成无锁状态，并撤销偏向锁，恢复到无锁（标志位为01）或轻量级锁（标志位为00）的状态。
3.  轻量级锁轻量级锁是指当锁是偏向锁的时候，却被另外的线程所访问，此时偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，线程不会阻塞，从而提高性能。轻量级锁的获取主要由两种情况：一旦有第二个线程加入锁竞争，偏向锁就升级为轻量级锁（自旋锁）。这里要明确一下什么是锁竞争：如果多个线程轮流获取一个锁，但是每次获取锁的时候都很顺利，没有发生阻塞，那么就不存在锁竞争。只有当某线程尝试获取锁的时候，发现该锁已经被占用，只能等待其释放，这才发生了锁竞争。在轻量级锁状态下继续锁竞争，没有抢到锁的线程将自旋，即不停地循环判断锁是否能够被成功获取。获取锁的操作，其实就是通过CAS修改对象头里的锁标志位。先比较当前锁标志位是否为“释放”，如果是则将其设置为“锁定”，比较并设置是原子性发生的。这就算抢到锁了，然后线程将当前锁的持有者信息修改为自己。长时间的自旋操作是非常消耗资源的，一个线程持有锁，其他线程就只能在原地空耗CPU，执行不了任何有效的任务，这种现象叫做忙等（busy-waiting）。如果多个线程用一个锁，但是没有发生锁竞争，或者发生了很轻微的锁竞争，那么synchronized就用轻量级锁，允许短时间的忙等现象。这是一种折衷的想法，短时间的忙等，换取线程在用户态和内核态之间切换的开销。

1.  1.  当关闭偏向锁功能时；
    2.  由于多个线程竞争偏向锁导致偏向锁升级为轻量级锁。

1.  重量级锁重量级锁显然，此忙等是有限度的（有个计数器记录自旋次数，默认允许循环10次，可以通过虚拟机参数更改）。如果锁竞争情况严重，某个达到最大自旋次数的线程，会将轻量级锁升级为重量级锁（依然是CAS修改锁标志位，但不修改持有锁的线程ID）。当后续线程尝试获取锁时，发现被占用的锁是重量级锁，则直接将自己挂起（而不是忙等），等待将来被唤醒。重量级锁是指当有一个线程获取锁之后，其余所有等待获取该锁的线程都会处于阻塞状态。简言之，就是所有的控制权都交给了操作系统，由操作系统来负责线程间的调度和线程的状态变更。而这样会出现频繁地对线程运行状态的切换，线程的挂起和唤醒，从而消耗大量的系统资。

**扩展阅读**

synchronized 用的锁是存在Java对象头里的，那么什么是对象头呢？我们以 Hotspot 虚拟机为例进行说明，Hopspot 对象头主要包括两部分数据：Mark Word（标记字段） 和 Klass Pointer（类型指针）。

*  Mark Word：默认存储对象的HashCode，分代年龄和锁标志位信息。这些信息都是与对象自身定义无关的数据，所以Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据。它会根据对象的状态复用自己的存储空间，也就是在运行期间Mark Word里存储的数据会随着锁标志位的变化而变化。
 *  Klass Point：对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。

那么，synchronized 具体是存在对象头哪里呢？答案是：存在锁对象的对象头的Mark Word中，那么MarkWord在对象头中到底长什么样，它到底存储了什么呢？

在32位的虚拟机中：

![f15d796804228a0edf9ea88bf15fbc76.png][]

在64位的虚拟机中：

![f4978daf082f59d78cf0138367334644.png][]

下面我们以 32位虚拟机为例，来看一下其 Mark Word 的字节具体是如何分配的：

*  无锁 ：对象头开辟 25bit 的空间用来存储对象的 hashcode ，4bit 用于存放对象分代年龄，1bit 用来存放是否偏向锁的标识位，2bit 用来存放锁标识位为01。
 *  偏向锁： 在偏向锁中划分更细，还是开辟 25bit 的空间，其中23bit 用来存放线程ID，2bit 用来存放 Epoch，4bit 存放对象分代年龄，1bit 存放是否偏向锁标识， 0表示无锁，1表示偏向锁，锁的标识位还是01。
 *  轻量级锁：在轻量级锁中直接开辟 30bit 的空间存放指向栈中锁记录的指针，2bit 存放锁的标志位，其标志位为00。
 *  重量级锁： 在重量级锁中和轻量级锁一样，30bit 的空间用来存放指向重量级锁的指针，2bit 存放锁的标识位，为11。
 *  GC标记： 开辟30bit 的内存空间却没有占用，2bit 空间存放锁标志位为11。

其中无锁和偏向锁的锁标志位都是01，只是在前面的1bit区分了这是无锁状态还是偏向锁状态。关于内存的分配，我们可以在git中openJDK中 markOop.hpp 可以看出：

public: // Constants enum \{ age\_bits = 4, lock\_bits = 2, biased\_lock\_bits = 1, max\_hash\_bits = BitsPerWord - age\_bits - lock\_bits - biased\_lock\_bits, hash\_bits = max\_hash\_bits > 31 ? 31 : max\_hash\_bits, cms\_bits = LP64\_ONLY(1) NOT\_LP64(0), epoch\_bits = 2 \};

*  age\_bits： 就是我们说的分代回收的标识，占用4字节。
 *  lock\_bits： 是锁的标志位，占用2个字节。
 *  biased\_lock\_bits： 是是否偏向锁的标识，占用1个字节。
 *  max\_hash\_bits： 是针对无锁计算的hashcode 占用字节数量，如果是32位虚拟机，就是 32 - 4 - 2 -1 = 25 byte，如果是64 位虚拟机，64 - 4 - 2 - 1 = 57 byte，但是会有 25 字节未使用，所以64位的 hashcode 占用 31 byte。
 *  hash\_bits： 是针对 64 位虚拟机来说，如果最大字节数大于 31，则取31，否则取真实的字节数。
 *  cms\_bits： 不是64位虚拟机就占用 0 byte，是64位就占用 1byte。
 *  epoch\_bits： 就是 epoch 所占用的字节大小，2字节。

## 4.21 如何实现互斥锁（mutex）？ ##

**参考答案**

在Java里面，最基本的互斥同步手段就是synchronized关键字，这是一种块结构（Block Structured）的同步语法。synchronized关键字经过Javac编译之后，会在同步块的前后分别形成monitorenter和monitorexit这两个字节码指令。这两个字节码指令都需要一个reference类型的参数来指明要锁定和解锁的对象。如果Java源码中的synchronized明确指定了对象参数，那就以这个对象的引用作为reference。如果没有明确指定，那将根据synchronized修饰的方法类型（如实例方法或类方法），来决定是取代码所在的对象实例还是取类型对应的Class对象来作为线程要持有的锁。

自JDK 5起，Java类库中新提供了java.util.concurrent包（J.U.C包），其中的java.util.concurrent.locks.Lock接口便成了Java的另一种全新的互斥同步手段。基于Lock接口，用户能够以非块结构（Non-Block Structured）来实现互斥同步，从而摆脱了语言特性的束缚，改为在类库层面去实现同步，这也为日后扩展出不同调度算法、不同特征、不同性能、不同语义的各种锁提供了广阔的空间。

## 4.22 分段锁是怎么实现的？ ##

**参考答案**

在并发程序中，串行操作是会降低可伸缩性，并且上下文切换也会减低性能。在锁上发生竞争时将通水导致这两种问题，使用独占锁时保护受限资源的时候，基本上是采用串行方式—-每次只能有一个线程能访问它。所以对于可伸缩性来说最大的威胁就是独占锁。

我们一般有三种方式降低锁的竞争程度：

1.  减少锁的持有时间；
2.  降低锁的请求频率；
3.  使用带有协调机制的独占锁，这些机制允许更高的并发性。

在某些情况下我们可以将锁分解技术进一步扩展为一组独立对象上的锁进行分解，这称为分段锁。其实说的简单一点就是：容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效的提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术，首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

如下图，ConcurrentHashMap使用Segment数据结构，将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问，能够实现真正的并发访问。所以说，ConcurrentHashMap在并发情况下，不仅保证了线程安全，而且提高了性能。

![cd7954b7af2ccdc2c8344cf7f5284e4a.png][]

## 4.23 说说你对读写锁的了解 ##

**参考答案**

与传统锁不同的是读写锁的规则是可以共享读，但只能一个写，总结起来为：读读不互斥、读写互斥、写写互斥，而一般的独占锁是：读读互斥、读写互斥、写写互斥，而场景中往往读远远大于写，读写锁就是为了这种优化而创建出来的一种机制。 注意是读远远大于写，一般情况下独占锁的效率低来源于高并发下对临界区的激烈竞争导致线程上下文切换。因此当并发不是很高的情况下，读写锁由于需要额外维护读锁的状态，可能还不如独占锁的效率高。因此需要根据实际情况选择使用。

在Java中ReadWriteLock的主要实现为ReentrantReadWriteLock，其提供了以下特性：

1.  公平性选择：支持公平与非公平（默认）的锁获取方式，吞吐量非公平优先于公平。
2.  可重入：读线程获取读锁之后可以再次获取读锁，写线程获取写锁之后可以再次获取写锁。
3.  可降级：写线程获取写锁之后，其还可以再次获取读锁，然后释放掉写锁，那么此时该线程是读锁状态，也就是降级操作。

## 4.24 volatile关键字有什么用？ ##

**参考答案**

当一个变量被定义成volatile之后，它将具备两项特性：

1.  保证可见性当写一个volatile变量时，JMM会把该线程本地内存中的变量强制刷新到主内存中去，这个写会操作会导致其他线程中的volatile变量缓存无效。
2.  禁止指令重排使用volatile关键字修饰共享变量可以禁止指令重排序，volatile禁止指令重排序有一些规则：即执行到volatile变量时，其前面的所有语句都执行完，后面所有语句都未执行。且前面语句的结果对volatile变量及其后面语句可见。

*   *  当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见，在其后面的操作肯定还没有进行；
     *  在进行指令优化时，不能将对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

注意，虽然volatile能够保证可见性，但它不能保证原子性。volatile变量在各个线程的工作内存中是不存在一致性问题的，但是Java里面的运算操作符并非原子操作，这导致volatile变量的运算在并发下一样是不安全的。

##### 4.25 谈谈volatile的实现原理 #####

**参考答案**

volatile可以保证线程可见性且提供了一定的有序性，但是无法保证原子性。在JVM底层volatile是采用“内存屏障”来实现的。观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令，lock前缀指令实际上相当于一个内存屏障，内存屏障会提供3个功能：

1.  它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；
2.  它会强制将对缓存的修改操作立即写入主存；
3.  如果是写操作，它会导致其他CPU中对应的缓存行无效。

## 4.11 如何实现子线程先执行，主线程再执行？ ##

**参考答案**

启动子线程后，立即调用该线程的join()方法，则主线程必须等待子线程执行完成后再执行。

**扩展阅读**

## 4.12 阻塞线程的方式有哪些？ ##

**参考答案**

当发生如下情况时，线程将会进入阻塞状态：

## 4.13 说一说synchronized与Lock的区别 ##

**参考答案**

## 4.14 说一说synchronized的底层实现原理 ##

**参考答案**

一、synchronized作用在代码块时，它的底层是通过monitorenter、monitorexit指令来实现的。

三、总结

## 4.15 synchronized可以修饰静态方法和静态代码块吗？ ##

**参考答案**

synchronized可以修饰静态方法，但不能修饰静态代码块。

当修饰静态方法时，监视器锁（monitor）便是对象的Class实例，因为Class数据存在于永久代，因此静态方法锁相当于该类的一个全局锁。

## 4.16 谈谈ReentrantLock的实现原理 ##

**参考答案**

ReentrantLock 结构如下图所示：

![75c8f0246246704d9cc80d087db70c46.png][]

## 4.17 如果不使用synchronized和Lock，如何保证线程安全？ ##

**参考答案**

1.  volatile

## 4.18 说一说Java中乐观锁和悲观锁的区别 ##

**参考答案**

## 4.19 公平锁与非公平锁是怎么实现的？ ##

**参考答案**

![517e0f5da8b88357be411e8e100fa4f7.jpeg][]

ReentrantLock 的公平锁和非公平锁都委托了 AbstractQueuedSynchronizer\#acquire 去请求获取。

public final void acquire(int arg) \{ if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); \}

## 4.20 了解Java中的锁升级吗？ ##

**参考答案**

![058ceeb35247be0547d1a42e1a9db678.png][]

1.  1.  当关闭偏向锁功能时；
    2.  由于多个线程竞争偏向锁导致偏向锁升级为轻量级锁。

**扩展阅读**

那么，synchronized 具体是存在对象头哪里呢？答案是：存在锁对象的对象头的Mark Word中，那么MarkWord在对象头中到底长什么样，它到底存储了什么呢？

在32位的虚拟机中：

![f83ea1c302edf51c37f8d62a39989196.png][]

在64位的虚拟机中：

![d669b0c56f48d7eac98181b3e49aba77.png][]

下面我们以 32位虚拟机为例，来看一下其 Mark Word 的字节具体是如何分配的：

## 4.21 如何实现互斥锁（mutex）？ ##

**参考答案**

## 4.22 分段锁是怎么实现的？ ##

**参考答案**

我们一般有三种方式降低锁的竞争程度：

1.  减少锁的持有时间；
2.  降低锁的请求频率；
3.  使用带有协调机制的独占锁，这些机制允许更高的并发性。

![3cbdf1dbf5790967a964df8fbeec52bc.png][]

## 4.23 说说你对读写锁的了解 ##

**参考答案**

在Java中ReadWriteLock的主要实现为ReentrantReadWriteLock，其提供了以下特性：

## 4.24 volatile关键字有什么用？ ##

**参考答案**

当一个变量被定义成volatile之后，它将具备两项特性：

##### 4.25 谈谈volatile的实现原理 #####

**参考答案**

[19a5e9042eb8b2654f821cc39792825c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/0cfe3eb61b3f4a3788933839b1e5eb02.png
[aa3cbf42fc7d20f636d12604210edf9b.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/d31d4bdcdcfb44c7a77c5837f98701fd.png
[c80eabef7483fc3c6acbfd6172df65b5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8630f796e4ae4b92935e7441d0fabe0d.png
[f15d796804228a0edf9ea88bf15fbc76.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/201ca6c65e24417baf94aeec92f8c9d2.png
[f4978daf082f59d78cf0138367334644.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/7a3e5009c5d7490a8dd5242c2b90f7be.png
[cd7954b7af2ccdc2c8344cf7f5284e4a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/7ce499ed8bb149bc8c0f6dd3f16ed329.png
[75c8f0246246704d9cc80d087db70c46.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/cc65619ed5404e3abceef35c12e80a05.png
[517e0f5da8b88357be411e8e100fa4f7.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/5eac4148219d4dac83903346ad035bd0.png
[058ceeb35247be0547d1a42e1a9db678.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/6b84462e3c2549d1b5efa3efcd872f48.png
[f83ea1c302edf51c37f8d62a39989196.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/4dac13b6e3a44ae6a9d4d224b341b40c.png
[d669b0c56f48d7eac98181b3e49aba77.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/599eda1ee29d4545b4dab4e367982b92.png
[3cbdf1dbf5790967a964df8fbeec52bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/18e06df1334048bfa29ab1c00237dab1.png