查看原文
其他

用 volatile 和 synchronized 实现单例

ImportNew ImportNew 2021-12-02

(给ImportNew加星标,提高Java技能)


编译:ImportNew/唐尤华

dzone.com/articles/demystifying-volatile-and-synchronized-again


现在,关于 `volatile` 和 `synchronized` 的用法仍然有很多争议。`volatile` 并不是什么新技术,然而理解它对于每个专业 Java 开发者来说很重要。另外,关于这个主题我没有找到好的总结文章和示例,促使我写下本文。


简单地说,`volatile` 关键字标记的变量具备"可见性",无论是读操作还是写操作都会强制刷新到主内存,确保多个线程可以看到变量修改后的值。另一方面,`synchronized` 也提供了**可见性**,通过添加互斥锁让所有受到加锁保护的代码与主内存同步。这样可以防止某个线程读取时其他线程正在更新该对象,造成读到的状态与实际不一致。


单例实现:使用 volatile Bean 模式


让我们通过一个延迟加载单例来帮助理解。示例采用双重检查锁定并实现了“volatile bean 模式”,代码如下:


> 译注:双重检查锁定模式(也被称为"双重检查加锁优化","锁暗示"(Lock hint)) 是一种软件设计模式用来减少并发系统中竞争和同步的开销。双重检查锁定模式首先验证锁定条件(第一次检查),只有通过锁定条件验证才真正的进行加锁逻辑并再次验证条件(第二次检查)。-- WikiPedia


```java
public class MutableSingleton {
private static volatile MutableSingleton INSTANCE;
private static final Object mutex = new Object();
private volatile boolean someFlag;
// 这个单例包含更多可变状态

private MutableSingleton(boolean someFlag) {
this.someFlag = someFlag;
}

public static MutableSingleton getInstance() {
MutableSingleton singleton = INSTANCE;
if (singleton != null)
return singleton;
synchronized (mutex) {
if (INSTANCE == null)
INSTANCE = new MutableSingleton(false);
return INSTANCE;
}
}

public boolean isSomeFlag() {
return someFlag;
}

public void setSomeFlag(boolean someFlag) {
this.someFlag = someFlag;
}
}
```


上面是一个可变的多线程单例实现,其中`INSTANCE` 和 `someFlag` 变量都标记为 `volatile`,但后者没有包含在 `synchronized` 代码块中。对单例进行的修改会立刻被其他线程看到(即可见性)。下面是测试用例:


```java
public class MutableSingletonTest {
private long counter = 0;
public Object[] execute(Object... arguments) {
final Timer timer = new Timer();
timer.schedule(new TimerTask() {
public void run() {
MutableSingleton.getInstance().setSomeFlag(true);
System.out.println("Timer interrupted main thread ...");
timer.cancel();
}
}, 1000);
while (!MutableSingleton.getInstance().isSomeFlag()) {
counter++;
};
System.out.println("Main thread was interrupted by timer ...");
return new Object[] { counter, MutableSingleton.getInstance().isSomeFlag() };
}
private class Worker implements Runnable {
@Override
public void run()
{
Object[] result = execute();
System.out.println(result[0]+"/"+result[1]);
}
}
public static void main(String[] args) throws InterruptedException {
MutableSingletonTest volatileExample = new MutableSingletonTest();
Thread thread1 = new Thread(volatileExample.new Worker(), "Worker-1");
thread1.start();
Thread.sleep(5000);
}
}
```


让我们快速了解整个程序。首先,`main()` 方法(第29行)创建了 `thread1`,在线程里执行 `execute()` 方法(第24行)。`execute()` (第5行)会新建 TimerThread(第7行)调度执行。接着,`thread1` 会循环等待(第14行),直到 `timer` 线程设置 `someFlag` 为 true(第9行)。使用 `MutableSingleton` 执行结果如下:


```shell
Timer interrupted main thread ...
Main thread was interrupted by timer ...
804404197/true
```


`timer` 线程与 `thread1` 正确同步,这是因为 `volatile` 在 `MutableSingleton` 上发挥了作用。


让单例失效


删除 `MutableSingleton` 中 `volatile` 关键字再次运行测试,结果应该是这样的(至少在我的机器上是这样的)。这意味着线程协调失效了:


```shell
Timer interrupted main thread ...
```


上面的运行结果表明 `thread1` 无法看到 `someFlag` 修改后的值。`timer` 线程把 `someFlag` 设置为 `true`,但由于 `volatile` 关键字已经删除,`thread1` 看不到更新后的值。


不使用 volatile 会怎么样?


现在让我们做一些别的测试:如果去掉 `MutableSingleton` 上的 `volatile` 关键字,给 `someFlag` 加上 `synchronized` 会怎么样呢?修改单例中的状态会对线程可见吗?下面是修改后的 `MutableSingleton` 类:


```java
public class MutableSingletonSynchronized {
private static MutableSingletonSynchronized INSTANCE;
private static final Object mutex = new Object();
private boolean someFlag;

// 这个单例包含更多可变状态
private MutableSingletonSynchronized(boolean someFlag) {
this.someFlag = someFlag;
}

public static MutableSingletonSynchronized getInstance() {
MutableSingletonSynchronized singleton = INSTANCE;
if (singleton != null)
return singleton;
synchronized (mutex) {
if (INSTANCE == null)
INSTANCE = new MutableSingletonSynchronized(false);
return INSTANCE;
}
}

public synchronized boolean isSomeFlag() {
return someFlag;
}

public synchronized void setSomeFlag(boolean someFlag) {
this.someFlag = someFlag;
}
}
```


在上面的代码中,访问 `someFlag` 已标记为 `synchronized` 并且删掉了 `volatile` 关键字。再次执行测试,控制台的输出如下。注意,这次没有使用 `volatile`。


```shell
Timer interrupted main thread ...
Main thread was interrupted by timer ...
60113040/true
```


看起来线程运行一切正常。原因在于访问 `someFlag` 的方法加上了 `synchronized` 关键字,这样本地线程与主内存能正确同步。这里有一个问题:如果采用 `synchronized` 访问,还需要 `volatile` 吗?答案很明确:视情况而定。


volatile 的隐藏特性


只要包含可变状态,采用双重检查锁定模式创建单例,都建议在 `INSTANCE` 字段上使用 `volatile`。因此对于上面的示例,虽然没有使用 `volatile` 线程也能够正常工作,但是应该加上 `volatile` 关键字。这里用到了 `volatile` 的另一个“特性”,有时候被称作“一次性安全发布”。该特性解决了双重检查锁定模式带来的问题,造成问题的原因如下:


由于缺乏同步机制,既可能看到其他线程写入后的新值,也可能看到对象之前的旧值。


这是什么意思?如果不使用 `volatile`,JIT 编译器可能会改变 `INSTANCE` 字段赋值操作(`MutableSingleton` 代码第17行),重新对赋值语句排序。例如,先把静态 `INSTANCE` 字段设为包含默认值的实例,再把可变成员字段 `someFlag` 设为构造函数传入的初始值。情况不凑巧时,会出现后面的线程先进入 `null` 检查(`MutableSingleton` 第13行),这时 `INSTANCE` 的值已经不是 `null`。此时,返回给客户端的实例包含的是不完整的默认值。由于可能出现这种复杂情况,推荐下面规则:


在应用双重检查锁定模式创建单例时,务必使用 `volatile`。


理由:


当单例 `INSTANCE` 字段加上 `volatile` 关键字时,编译器不会对该字段赋值重新排序。


不可变对象


对于不可变单例,情况又有一些不同。如果单例是不可变对象,那么即使不使用 `volatile`,双重检查锁定模式的延迟初始化也能正常运行。[这是因为][1]读写不可变对象都是原子操作。因此,这里要小心确认,引用的对象是否真的不可变:


[1]:http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html


对于不可变对象,在双重检查锁定模式中不强制使用 `volatile`。


volatile 没有互斥锁


使用 `volatile` 时还有一点需要注意:尽管 `volatile` 能够确保所有更改对线程都可以见,但并没有像 `synchronized` 那样增加互斥锁。这意味着代码并非线程安全。


```java
private static volatile int nextSerialNumber = 0;
public static int generateNextSerialNumber() {
return nextSerailNumber++;
}
```


修改 `nextSerialNumber` 对所有线程可见。但是由于(++)实际上执行了读写两个操作,当多个线程调用 `generateNextSerialNumber()` 访问同一个地址时,可能会出现数据竞争。可以通过添加 `synchronized` 解决:


```java
private static int nextSerialNumber = 0;
public static synchronized int generateNextSerialNumber() {
return nextSerailNumber++;
}
```


只要访问 `nextSerialNumber` 字段标记为 `synchronized`,就不必再使用 `volatile`。


结合 volatile 与 synchronized


综上所述,一个线程安全、性能优良的完整单例模式看起来应该像下面这样:


```java
public class MutableSingletonComplete {
private static volatile MutableSingletonComplete INSTANCE;
private static final Object mutex = new Object();
private volatile boolean someFlag;
private volatile int counter;
// 这个单例包含更多可变状态
private MutableSingletonComplete(boolean someFlag) {
this.someFlag = someFlag;
}
public static MutableSingletonComplete getInstance() {
MutableSingletonComplete singleton = INSTANCE;
if (singleton != null)
return singleton;
synchronized (mutex) {
if (INSTANCE == null)
INSTANCE = new MutableSingletonComplete(false);
return INSTANCE;
}
}
public boolean isSomeFlag() {
return someFlag;
}
public void setSomeFlag(boolean someFlag) {
this.someFlag = someFlag;
}
public int getCounter() {
return counter;
}
public synchronized void incrementCounter() {
counter++;
}
}
```


总结:


  • 对 `INSTANCE` 字段使用 `volatile` 关键字,应用一次性安全发布;

  • 对单例属性使用 `volatile` 关键字,保持可见性;

  • 如果修改状态不是原子操作,即使该字段声明为 `volatile`,也需要使用 `synchronized` 关键字,使用互斥锁;

  • 如果单例中的 `volatile` 属性是对象引用,要么该对象也是线程安全的实现,要么对象本身不可变。这样实现会更加完善。


好了,今天的困惑已经够多了,让我们喝杯咖啡。示例代码可以在[这里][2]找到。


希望本文的示例对系统化了解 `volatile` 有所帮助。文中内容难免有错漏,欢迎评论、提问、抛出你的想法。


[2]:https://github.com/nschlimm/playground-java8/tree/master/src/main/java/org/projectbarbel/playground/revisitevolatile


推荐阅读

(点击标题可跳转阅读)

Java 并发编程 :volatile 关键字解析

死磕 Java 并发:深入分析 synchronized 的实现原理

就是要你懂 Java 中 volatile 关键字实现原理


看完本文有收获?请转发分享给更多人

关注「ImportNew」,提升Java技能

好文章,我在看❤️

: . Video Mini Program Like ,轻点两下取消赞 Wow ,轻点两下取消在看

您可能也对以下帖子感兴趣

文章有问题?点此查看未经处理的缓存