28. Immutability模式：如何利用不变性解决并发问题？- 并发设计模式

解决并发问题，其实最简单的办法就是让共享变量只有读操作，而没有写操作。由此， 不变性（Immutability）模式。所谓不变性，简单来讲，就是对象一旦被创建之后，状态就不再发生变化

1. 快速实现具备不可变性的类

实现方法：将一个类所有的属性都设置成final的，并且只允许存在只读方法，那么这个类基本上就具备不可变性，更严格的做法，这个类本身也是final的，不允许继承。

常用的String，Long，Integer，Double都是不可变的，不可变类的三点要求：类和属性都是final的，所有方法均是只读的。

具备不可变性的类，需要提供类似修改的功能，做法就是创建一个新的不可变对象。

2. 利用享元模式避免创建重复对象

享元模式（Flyweight Pattern）。利用享元模式可以减少创建对象的数量，从而减少内存占用。

享元模式本质上其实就是一个对象池，利用享元模式创建对象的逻辑：创建之前，首先去对象池里看看是不是存在；如果已经存在，就利用对象池里的对象；如果不存在，就会新创建一个对象，并且把这个新创建出来的对象放进对象池里。

Long这个类并没有照搬享元模式，Long内部维护了一个静态的对象池，仅缓存了[-128,127]之间的数字，这个对象池在JVM启动的时候就创建好了，而且这个对象池一直都不会变化，也就是说它是静态的。

Long valueOf(long l) {
		final int offset = 128;
		// [-128,127]直接的数字做了缓存
		if (l >= -128 && l <= 127) {
			return LongCache.cache[(int) l + offset];
		}
		return new Long(l);
	}

	// 缓存，等价于对象池
	// 仅缓存[-128,127]直接的数字
	static class LongCache {
		static final Long cache[] = new Long[-(-128) + 127 + 1];
		static {
			for (int i = 0; i < cache.length; i++)
				cache[i] = new Long(i - 128);
		}
	}

基础类型的包装类都不适合做锁，因为它们内部用到了享元模式，这会导致看上去私有的锁，其实是共有的

3. 使用Immutability模式的注意事项

注意点：

• 对象的所有属性都是final的，并不能保证不可变性；
• 不可变对象也需要正确发布。

在Java语言中，final修饰的属性一旦被赋值，就不可以再修改，但是如果属性的类型是普通对象，那么这个普通对象的属性是可以被修改的。在使用Immutability模式的时候一定要确认保持不变性的边界在哪里，是否要求属性对象也具备不可变性。

不可变对象虽然是线程安全的，但是并不意味着引用这些不可变对象的对象就是线程安全的。例如在下面的代码中，Foo具备不可变性，线程安全，但是类Bar并不是线程安全的，类Bar中持有对Foo的引用foo，对foo这个引用的修改在多线程中并不能保证可见性和原子性。

//Foo线程安全
final class Foo{
  final int age=0;
  final int name="abc";
}
//Bar线程不安全
class Bar {
  Foo foo;
  void setFoo(Foo f){
    this.foo=f;
  }
}

仅需要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;
			}
		}
	}
}

4. 总结

Java语言里面的String和Long、Integer、Double等基础类型的包装类都具备不可变性，Immutability模式是最简单的解决并发问题的方法。

具备不变性的对象，只有一种状态，这个状态由对象内部所有的不变属性共同决定。

更简单的不变性对象，那就是无状态。无状态对象内部没有属性，只有方法。

5. 课后思考

下面的示例代码中，Account的属性是final的，并且只有get方法，那这个类是不是具备不可变性呢？

public final class Account {
	private final StringBuffer user;

	public Account(String user) {
		this.user = new StringBuffer(user);
	}

	public StringBuffer getUser() {
		return this.user;
	}

	public String toString() {
		return "user" + user;
	}
}

个人思考：应该不具备，问题在构造函数，通过构造函数，同个用户可能有多个Account。