当多个线程同时访问同一个资源,并且其中的一个或者多个线程对这个资源进行了写操作,才会产生 竞态条件(多个线程同时读同一个资源不会产生竞态条件)。
解决共享数据的线程安全问题,其实最简单的办法就是让共享变量只有读操作,而没有写操作。业界将这种方法称为 Immutability 不可变模式。
用 Immutability 不可变模式,来解决共享数据被多线程访问/修改 的并发安全问题,很多人可能觉得有点陌生,其实我们每天都在享受它的战果。Java 语言里面的 String 和 Long、Integer、Double 等基础类型的包装类都具备不可变性,这些对象的线程安全性都是靠不可变性来保证的。
这个办法如此重要,以至于被上升到了一种解决并发问题的设计模式:不变性(Immutability)模式
。所谓不变性,简单来讲,就是对象一旦被创建之后,状态就不再发生变化
。换句话说,就是变量一旦被赋值,就不允许修改了(没有写操作);没有修改操作,也就是保持了不变性。
不变模式和只读属性的区别
“不变”(Immutable)和“只读”(Read Only)是不同的。当一个变量是“只读”时,变量的值不能直接改变,但是可以在其它变量发生改变的时候发生改变。比如,一个人的出生年月日是“不变”属性,而一个人的年龄便是“只读”属性,但是不是“不变”属性。随着时间的变化,一个人的年龄会随之发生变化,而一个人的出生年月日则不会变化。这就是“不变”和“只读”的区别。(摘自《Java与模式》第34章)
不可变性说得这么玄,是不是和平常编程没有太大关系呢? 其实不然,Java中的final 关键字提供了非常好的“不可变”语义。
快速实现具备不可变性的类
实现一个具备不可变性的类,还是挺简单的。将一个类所有的属性都设置成 final 的,并且只允许存在只读方法,那么这个类基本上就具备不可变性了
。更严格的做法是这个类本身也是 final 的
,也就是不允许继承。因为子类可以覆盖父类的方法,有可能改变不可变性,所以推荐你在实际工作中,使用这种更严格的做法。
所有属性设置为私有,并用final标记
创建时,用构造方法赋值
不提供setter方法(其实提供了也没用,因为用final修饰了)
JDK 中 Immutability 模式的应用
Java SDK 里很多类都具备不可变性,只是由于它们的使用太简单,最后反而被忽略了。例如经常用到的 String 和 Long、Integer、Double 等基础类型的包装类都具备不可变性,这些对象的线程安全性都是靠不可变性来保证的。如果你仔细翻看这些类的声明、属性和方法,你会发现它们都严格遵守不可变类的三点要求:类和属性都是 final 的,所有方法均是只读的
在不变模式中,final关键字起到了重要的作用。对属性修饰final确保所有数据只能在对象被构造时赋值一次,之后,就永远不会发生改变。而对class修饰final确保了类不会有子类。根据里氏替换原则,子类可以完全替代父类。如果父类是不变的,那么子类也必须是不变的。
结合 String 的 replace() 方法源代码来String 如何实现不可变性的:String 这个类以及它的属性 value[] 都是 final 的;而 replace() 方法的实现,就的确没有修改 value[],而是将替换后的字符串作为返回值返回了,相对于新创建了一个字符串。
public final class String {
private final char value[];
// ...
}
如果具备不可变性的类,需要提供类似修改的功能,具体该怎么操作呢?做法很简单,j那就是创建一个新的不可变对象
,就像String.replace() 方法一样,这是与可变对象的一个重要区别,可变对象往往是修改自己的属性。
所有的修改操作都创建一个新的不可变对象,你可能会有这种担心:是不是创建的对象太多了,有点太浪费内存呢?是的,这样做的确有些浪费,那如何解决呢?
利用享元模式避免创建重复对象
如果你熟悉面向对象相关的设计模式,相信你一定能想到享元模式(Flyweight Pattern)。
享元模式(Flyweight Pattern)主要用于减少创建对象的数量,以减少内存占用和提高性能。这种类型的设计模式属于结构型模式,它提供了减少对象数量从而改善应用所需的对象结构的方式。
享元模式尝试重用现有的同类对象,如果未找到匹配的对象,则创建新对象。
享元模式本质上其实就是一个对象池
,利用享元模式创建对象的逻辑也很简单:创建之前,首先去对象池里看看是不是存在;如果已经存在,就利用对象池里的对象;如果不存在,就会新创建一个对象,并且把这个新创建出来的对象放进对象池里。
JDK中 Long、Integer、Short、Byte 等这些基本数据类型的包装类都用到了享元模式。其实String对象使用的是常量池,未销毁的String对象都在其中,也是一种享元模式的体现。
Java的数值包装类型没有照搬享元模式,例如 Long 内部维护了一个静态的对象池,仅缓存了 [-128,127] 之间的数字,这个对象池在 JVM 启动的时候就创建好了,而且这个对象池一直都不会变化,也就是说它是静态的。之所以采用这样的设计,是因为 Long 这个对象的状态共有 2**64 种,实在太多,不宜全部缓存,而 [-128,127] 之间的数字利用率最高。下面的示例代码出自 Java 1.8,valueOf() 方法就用到了 LongCache 这个缓存。
所以也就解释了 “Integer 和 String 类型的对象不适合做锁”,其实基本上所有的基础类型的包装类都不适合做锁,因为它们内部用到了享元模式,这会导致看上去私有的锁,其实是共有的。
例如在下面代码中,本意是 A 用锁 al,B 用锁 bl,各自管理各自的,互不影响。但实际上 al 和 bl 是一个对象,结果 A 和 B 共用的是一把锁。
使用 Immutability 模式的注意事项
在使用 Immutability 模式的时候,需要注意以下两点:
对象的所有属性都是 final 的,并不能保证不可变性;
不可变对象也需要正确发布。
在 Java 语言中,final 修饰的属性一旦被赋值,就不可以再修改,但是如果属性的类型是普通对象,那么这个普通对象的属性是可以被修改的。例如下面的代码中,Bar 的属性 foo 虽然是 final 的,依然可以通过 setAge() 方法来设置 foo 的属性 age。所以,在使用 Immutability 模式的时候一定要确认保持不变性的边界在哪里,是否要求属性对象也具备不可变性
下面我们再看看如何正确地发布不可变对象。不可变对象虽然是线程安全的,但是并不意味着引用这些不可变对象的对象就是线程安全的。例如在下面的代码中,Foo 具备不可变性,线程安全,但是类 Bar 并不是线程安全的,类 Bar 中持有对 Foo 的引用 foo,对 foo 这个引用的修改在多线程中并不能保证可见性和原子性。
如果你的程序仅仅需要 foo 保持可见性,无需保证原子性,那么可以将 foo 声明为 volatile 变量,这样就能保证可见性。如果你的程序需要保证原子性,那么可以通过原子类来实现。下面的示例代码是合理库存的原子化实现,你应该很熟悉了,其中就是用原子类解决了不可变对象引用的原子性问题。
public class SafeWM {
class WMRange{
final int upper;
final int lower;
WMRange(int upper,int lower){
// 省略构造函数实现
}
}
final AtomicReference<WMRange>
rf = new AtomicReference<>(
new WMRange(0,0)
);
// 设置库存上限
void setUpper(int v){
while(true){
WMRange or = rf.get();
// 检查参数合法性
if(v < or.lower){
throw new IllegalArgumentException();
}
WMRange nr = new
WMRange(v, or.lower);
if(rf.compareAndSet(or, nr)){
return;
}
}
}
}