并发设计模式--Immutability模式

概念

解决并发问题，其实最简单的办法就是让共享变量只有读操作，而没有写操作。这个办法如此重要，以至于被上升到了一种解决并发问题的设计模式：不变性（Immutability）模式。所谓不变性，简单来讲，就是对象一旦被创建之后，状态就不再发生变化。换句话说，就是变量一旦被赋值，就不允许修改了（没有写操作）；没有修改操作，也就是保持了不变性。

实现

将一个类所有的属性都设置成 final 的，并且只允许存在只读方法，那么这个类基本上就具备不可变性了。更严格的做法是这个类本身也是 final 的，也就是不允许继承。因为子类可以覆盖父类的方法，有可能改变不可变性，所以推荐大家在实际工作中，使用这种更严格的做法。

应用示例

JDK包装类

Java SDK 里很多类都具备不可变性，例如经常用到的 String 和 Long、Integer、Double 等基础类型的包装类都具备不可变性，这些对象的线程安全性都是靠不可变性来保证的。仔细翻看这些类的声明、属性和方法，我们会发现它们都严格遵守不可变类的三点要求：类和属性都是final的，所有方法均是只读的。以 String 为例：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
     /** The value is used for character storage. */
    private final char value[];

    ...

    //	字符替换
    public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */

            // 定位到需要替换的字符位置
            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                // 创建⼀个buf[]，这是关键，⽤来保存替换后的字符串
                char buf[] = new char[len];
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                // 创建⼀个新的字符串返回，原字符串不会发⽣任何变化
                return new String(buf, true);
            }
        }
        // ⽆需替换，直接返回this		
        return this;
    }

    ...
}

通过分析 String 的实现，不难发现，如果具备不可变性的类，需要提供类似修改的功能，具体该怎么操作呢？做法很简单，那就是创建一个新的不可变对象，这是与可变对象的一个重要区别，可变对象往往是修改自己的属性。

享元模式的运用

如果所有的修改操作都创建一个新的不可变对象，我们可能会担心：是不是创建的对象太多了，有点太浪费内存呢？是的，这样做的确有些浪费，因此我们可以利用享元模式来减少创建对象的数量，从而减少内存占用。

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

下面我们就以 Long 这个类作为例子，看看它是如何利用享元模式来优化对象的创建的。Long 这个类并没有照搬享元模式，Long 内部维护了一个静态的对象池，仅缓存了[-128,127]之间的数字，这个对象池在 JVM 启动的时候就创建好了，而且这个对象池一直都不会变化，也就是说它是静态的。之所以采用这样的设计，是因为 Long 这个对象的状态共有 2 种，实在太多，不宜全部缓存，而[-128,127]之间的数字利用率最高。下面的示例代码出自 Java 1.8，valueOf() 方法就用到了LongCache 这个缓存：

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

// 缓存，等价于对象池仅缓存[-128,127]直接的数字
private static class LongCache {
    private 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);
    }
}

需要注意的是，正是因为包装类内部用到了享元模式，这会导致看上去私有的锁，其实是共有的，因此基本上所有的基础类型的包装类都不适合做锁，因为它们例如在下面代码中，本意是 A 用锁 al，B 用锁 bl，各自管理各自的，互不影响。但实际上 al 和 bl 是一个对象，结果 A 和 B 共用的是一把锁。

class A {
    Long al=Long.valueOf(1);
    public void setAX(){
        synchronized (al) {
            //省略代码⽆数
        }
    }
}
class B {
    Long bl=Long.valueOf(1);
    public void setBY(){
        synchronized (bl) {
            //省略代码⽆数
        }
    }
}

注意事项

在使用 Immutability 模式的时候，需要注意以下两点：

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

下面我们再看看如何正确地发布不可变对象。不可变对象虽然是线程安全的，但是并不意味着引用这些不可变对象的对象就是线程安全的。例如在下面的代码中，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;
            }
        }
    }
}

无状态

具备不变性的对象，只有一种状态，这个状态由对象内部所有的不变属性共同决定。其实还有一种更简单的不变性对象，那就是无状态。无状态对象内部没有属性，只有方法。除了无状态的对象，我们可能还听说过无状态的服务、无状态的协议等等。无状态有很多好处，最核心的一点就是性能。在多线程领域，无状态对象没有线程安全问题，无需同步处理，自然性能很好；在分布式领域，无状态意味着可以无限地水平扩展，所以分布式领域里面性能的瓶颈一定不是出在无状态的服务节点上。