吊打面试官(五)--Java关键字volatile一文全掌握
前言
volatile 是 Java 中的一个关键字，用于声明变量。当一个变量被声明为 volatile时，它可以确保线程对这个变量的读写都是直接从主内存中进行的。这也是面试官最爱问的点，接下来我们详细介绍这个关联字各个方面。
volatile关键字使用详细介绍
1. 可见性
当一个线程修改了一个 volatile变量的值，其他线程能够立即看到修改后的值。
这是因为 volatile变量不会被缓存在寄存器或其他处理器不可见的地方，因此保证了每次读取 volatile变量都会从主内存中读取最新的值。
2. 有序性
volatile变量的读写操作具有一定的有序性，即禁止了指令重排序优化，就是禁止编译器自动重新排序。
这意味着，在一个线程中，对 volatile变量的写操作一定发生在后续对这个变量的读操作之前。
3. 使用场景
volatile 关键字通常用于以下场景：* 当多个线程共享一个变量，并且至少有一个线程会修改这个变量时。* 当需要确保变量的修改对所有线程立即可见时。* 当变量的状态不需要依赖于之前的值，或者不需要与其他状态变量共同参与不变约束时。
4. 代码示例
下面是一个使用 volatile 关键字的简单示例：
public class VolatileExample {
private volatile boolean flag = false;
public void setFlag(boolean flag) {
this.flag = flag;
}
public boolean getFlag() {
return this.flag;
}
public static void main(String[] args) {
VolatileExample example = new VolatileExample();
// 线程1：修改flag的值
new Thread(() -> {
try {
Thread.sleep(1000); // 模拟一些操作
} catch (InterruptedException e) {
e.printStackTrace();
}
example.setFlag(true);
System.out.println("Flag被设置为true");
}).start();
// 线程2：检查flag的值
new Thread(() -> {
while (!example.getFlag()) {
// 忙等待，直到flag变为true
}
System.out.println("检测到Flag为true");
}).start();
}
}在这个示例中，我们有两个线程。
线程1在休眠1秒后将 `flag` 设置为 `true`，而线程2则不断检查 `flag` 的值，直到它变为 `true`。由于 `flag` 被声明为 volatile，因此线程2能够立即看到线程1对 `flag` 的修改，并退出循环。
5.使用注意事项*
volatile关键字不能保证原子性。如果需要对变量进行复合操作（例如自增），则应该使用 `synchronized` 关键字或其他并发工具（如 `AtomicInteger`）来确保线程安全。
* 过度使用 volatile可能会导致性能下降，因为它会禁止编译器和处理器对代码进行某些优化。因此，在使用 volatile时应该仔细考虑其必要性。
volatile关键字使用场景举例
1.状态标志位
在多线程程序中， volatile 关键字用于表示一个状态标志位，例如程序运行状态或中断使能状态。这些状态标志位通常会被多个线程访问和修改，使用 volatile 可以确保它们的可见性和有序性。使用 volatile 关键字可以防止线程间的数据不一致性问题，确保每个线程都能看到最新的状态标志位值。这对于控制线程行为和同步操作非常关键。
代码举例：
public class VolatileExample {
private volatile boolean flag = false;
public void startTask() {
new Thread(() -> {
try {
Thread.sleep(1000); // 模拟耗时操作
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = true;
System.out.println("Flag has been set to true.");
}).start();
}
public void monitorTask() {
new Thread(() -> {
while (!flag) {
// 循环等待，直到flag变为true
}
System.out.println("Flag is now true. Task can proceed.");
}).start();
}
public static void main(String[] args) {
VolatileExample example = new VolatileExample();
example.startTask();
example.monitorTask();
}
}2.单例模式的双重检查锁
在单例模式中， volatile 关键字用于确保单例实例在多线程环境下的唯一性和可见性。通过将实例声明为 volatile ，可以防止线程在读取和写入实例时看到不一致的值。在多线程环境中， volatile 关键字可以防止指令重排序，确保单例实例的初始化操作在所有线程中都完成，从而避免潜在的线程安全问题。
代码举例：
public class Singleton {
private static volatile Singleton instance = null;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}3.线程安全的计数器
volatile 关键字也适用于简单的计数器，如统计某个事件的发生次数。虽然 volatile 不能保证复合操作的原子性，但它可以确保每次读取和写入操作都是对主内存的访问。在需要统计事件发生次数的场景中， volatile 关键字可以确保计数的准确性，防止线程在读取和写入计数器时看到不一致的值。
代码举例：
public class VolatileCounter {
private volatile int count = 0;
public void increment() {
count++;
}
public int getCount() {
return count;
}
public static void main(String[] args) {
VolatileCounter counter = new VolatileCounter();
// 启动多个线程进行计数
for (int i = 0; i < 10; i++) {
new Thread(() -> {
for (int j = 0; j < 1000; j++) {
counter.increment();
}
}).start();
}
// 等待所有线程完成
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Final count: " + counter.getCount());
}
}4.直接访问硬件寄存器
在嵌入式系统编程中，直接与硬件设备交互时，使用 volatile 可以确保每次读写操作都直接从内存中进行，而不是使用寄存器缓存中的值。这可以避免编译器对寄存器访问的优化，确保与硬件的交互是准确的。在嵌入式系统编程中， volatile 关键字的作用至关重要。它可以防止编译器对硬件寄存器访问的优化，确保每次读写操作都是对实际硬件的访问，从而提高系统的稳定性和可靠性。
使用JNI作为代码举例：
Java代码：
public class HardwareAccess {
// 声明本地方法
public native int readRegister();
// 加载动态链接库
static {
System.loadLibrary("hardware");
}
public static void main(String[] args) {
HardwareAccess ha = new HardwareAccess();
int registerValue = ha.readRegister();
System.out.println("Register value: " + Integer.toHexString(registerValue));
}
}
生成JNI头文件：
javac HardwareAccess.java
javac -h . HardwareAccess.java
编写C代码实现本地方法：
#include <jni.h>
#include "HardwareAccess.h"
#include <stdio.h>
JNIEXPORT jint JNICALL Java_HardwareAccess_readRegister(JNIEnv *env, jobject obj) {
// 模拟读取寄存器数据
printf("Reading register...\n");
int simulatedRegisterValue = 0x1234;
return simulatedRegisterValue;
}
编译C代码为动态链接库：
Linux：gcc -shared -fpic -o libhardware.so -I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux HardwareAccess.c
运行Java程序：
java -Djava.library.path=. HardwareAccess5.中断处理程序中的标志位
在处理中断时，通常需要对中断标志进行读写操作。使用 volatile 可以确保中断处理程序对标志位的修改能够立即被其他线程看到，从而确保中断处理的正确性。在中断处理程序中使用 volatile 关键字可以确保中断标志位的修改对所有线程立即可见，避免因中断处理导致的线程间数据不一致问题。
代码举例：
public class InterruptExample {
private volatile boolean interrupted = false;
public void run() {
while (!interrupted) {
// 执行一些任务
}
// 线程被中断，执行清理操作
}
public void setInterrupted() {
interrupted = true;
}
public static void main(String[] args) {
InterruptExample example = new InterruptExample();
Thread thread = new Thread(example::run);
thread.start();
// 模拟中断线程
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
example.setInterrupted();
}
}6.信号处理程序中的标志位
在信号处理程序中，使用 volatile 可以确保信号处理程序对标志位的修改能够立即被其他线程看到，从而确保信号处理的正确性。
在信号处理程序中使用 volatile 关键字可以防止指令重排序，确保信号处理程序对标志位的修改对所有线程立即可见，从而提高信号处理的可靠性和稳定性。
信号处理通常通过 sun.misc.Signal 和 sun.
misc.SignalHandler 来实现，但需要注意的是，这些类并不是Java标准API的一部分，可能在不同的JDK实现中有所不同。
代码举例：
import sun.misc.Signal;
import sun.misc.SignalHandler;
public class SignalExample {
private volatile boolean signalReceived = false;
public void handleSignal() {
Signal.handle(new Signal("INT"), new SignalHandler() {
@Override
public void handle(Signal signal) {
signalReceived = true;
}
});
}
public void run() {
while (!signalReceived) {
// 执行一些任务
}
// 信号处理程序已设置标志位，执行清理操作
}
public static void main(String[] args) {
SignalExample example = new SignalExample();
example.handleSignal();
new Thread(example::run).start();
// 模拟发送信号
try {
Thread.sleep(1000);
Signal.raise(new Signal("INT"));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}7.防止优化编译器优化
在某些情况下，编译器可能会对代码进行优化，导致变量的值在多线程环境中不一致。使用 volatile 可以防止这种优化，确保每次访问变量时都从内存中读取最新的值。在需要防止编译器优化的场景中， volatile 关键字可以确保变量的值始终是最新的，避免因编译器优化导致的线程间数据不一致问题。
代码举例：
public class OptimizationExample {
private volatile int counter = 0;
public void increment() {
counter++;
}
public int getCounter() {
return counter;
}
public static void main(String[] args) {
OptimizationExample example = new OptimizationExample();
// 启动多个线程进行计数
for (int i = 0; i < 10; i++) {
new Thread(() -> {
for (int j = 0; j < 1000; j++) {
example.increment();
}
}).start();
}
// 等待所有线程完成
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Final counter value: " + example.getCounter());
}
}在这个示例中， volatile 关键字确保了对 counter 变量的每次访问都直接从内存中进行，而不是使用寄存器缓存中的值，从而防止了编译器优化导致的不一致问题。
在多线程编程中，volatile关键字与synchronized关键字有何不同？
volatile 关键字
可见性：
volatile 确保了变量的修改对所有线程是可见的。当一个线程修改了 volatile 变量的值，这个变化会立即被写入主内存，而其他线程在读取该变量时会从主内存中获取最新的值。
禁止指令重排序：
volatile 可以防止编译器和处理器对代码进行优化，确保指令按照程序的顺序执行。
适用场景：
volatile 适用于那些被多个线程访问但并不涉及复合操作（例如递增操作）的变量。它主要用于状态标志、控制变量等场景。
性能：
由于 volatile 不需要使用锁，因此它的性能开销相对较小。
synchronized关键字
互斥性：
synchronized 确保同一时刻只有一个线程可以访问被保护的代码块或方法，从而避免了多个线程之间的竞争条件。
有序性：
synchronized 通过锁定和解锁机制，隐式地保证了代码执行的顺序性。
适用场景：
synchronized 适用于需要保证原子性和线程安全性的场景，例如对共享资源的读写操作。
性能：
synchronized 可能会带来较大的性能开销，因为它涉及到线程的阻塞和唤醒，以及上下文切换。总的来说， volatile 和 synchronized 在多线程编程中各有其独特的用途。 volatile 适用于需要保证变量可见性且不涉及复杂操作的场景，而 synchronized 则适用于需要保证代码块或方法原子性和有序性的场景。
volatile关键字在Java中的实现机制是什么？
volatile 关键字在Java中的实现机制主要涉及Java内存模型（JMM）、内存屏障（Memory Barrier）和缓存一致性协议（如MESI协议）。
Java内存模型（JMM）：
主内存与工作内存：
JMM定义了线程如何与主内存和线程本地内存交互。主内存是所有线程共享的内存区域，存储所有变量的值。每个线程有自己的本地内存，存储从主内存中读取的变量副本。
内存可见性：当一个线程修改了 volatile 变量的值，这个修改会立即刷新到主内存，并通知其他线程更新缓存。其他线程在读取该变量时，会从主内存中重新加载最新的值。
内存屏障（Memory Barrier）：
写屏障（Store Barrier）：
在写操作之后插入，确保写操作对其他线程可见。
读屏障（Load Barrier）：在读操作之前插入，确保读操作从主内存中加载最新值。volatile 通过插入内存屏障来禁止指令重排序，确保变量的读写操作按照程序的顺序执行。
缓存一致性协议（MESI协议）：
MESI协议：现代CPU通常有多级缓存（L1、L2、L3），为了保证缓存一致性，CPU使用缓存一致性协议（如MESI协议）。
volatile 写操作会触发缓存行状态变为Modified，并强制将数据写回主内存； volatile 读操作会触发缓存行状态变为Shared，并从主内存中加载最新数据。
JVM层面的实现：
字节码层面的实现：在字节码层面， volatile 变量的读写操作会被标记为ACC_VOLATILE标志。JVM在执行这些操作时会插入内存屏障。
JIT编译器的优化：JIT编译器在生成机器码时，会根据 volatile 的语义插入内存屏障。例如，在x86架构下， volatile 写操作会插入StoreLoad屏障，确保写操作对其他线程可见。
硬件层面的实现：
x86架构：在x86架构下， volatile 写操作会使用LOCK前缀指令，强制将数据写回主内存，并通知其他CPU缓存失效。
ARM架构：在ARM架构下， volatile 通过内存屏障指令（如DMB）来实现。通过上述机制， volatile 关键字确保了多线程环境下变量的可见性和有序性，从而避免了由于线程间数据不一致导致的问题。
volatile关键字可能导致性能下降问题
volatile关键字在以下情况下可能会导致性能下降：
1. 缓存行争用：
当多个线程同时访问被volatile修饰的变量时，可能会导致缓存行争用。这是因为每个处理器都有自己的缓存，当多个线程访问同一个缓存行中的数据时，可能会导致缓存失效，从而需要从主内存中重新加载数据。这种缓存失效和重新加载的过程会增加访问延迟，从而降低性能。
2. 内存屏障开销：
volatile关键字会引入内存屏障，以确保变量的修改对所有线程都是可见的。内存屏障是一种特殊的指令，用于在编译器和处理器之间同步内存访问顺序。虽然内存屏障可以确保正确的内存可见性，但它也可能导致性能下降，因为它会限制编译器和处理器对指令进行重排序的能力。
3. 禁止编译器优化：
volatile关键字禁止编译器对变量进行优化，以确保每次访问该变量时都能获取到最新的值。这可能会导致生成的代码相对较多，从而影响程序性能。
4. 原子操作开销：
volatile关键字可以确保对变量的读取和写入都是原子的，这意味着它们不会被其他线程的操作中断。原子操作本身可能比非原子操作更昂贵，因为它们需要额外的处理器资源来保证操作的完整性。尽管volatile关键字可能会导致性能下降，但在许多情况下，这种影响是可以接受的。例如，当多个线程需要共享一个简单的状态变量（如计数器）时，使用volatile关键字可以确保所有线程都能看到最新的值，而不会引入不必要的复杂性或性能开销。
前言
volatile 是 Java 中的一个关键字，用于声明变量。本文我们讲述了它的详细使用场景，典型使用案例，和synchronized关键字的对比，它的实现原理，性能问题等。基本覆盖了它涉及的各个方面，请各位看官自行取用。
求关注哦