Immutability模式：利用不变性解决并发问题

多线程同时读写同一共享变量存在并发问题。(如果只有读，没有写，是没有并发问题的)。

解决并发问题，最简单的办法就是让共享变量只有读操作，没有写操作。
上升为一种解决并发问题的设计模式：不变性(Immutability)模式。所谓不变形，就是对象一旦被创建之后，状态就不再发生变化。也就是变量一旦被赋值，就不允许修改了(没有写操作)；没有修改操作，也就保持了不变性。

实现具备不可变性的类

将一个类所有的属性都设置成final的，并且只允许存在只读方法，那么这个类基本上就具备不可变性了。更严格的做法是这个类本身也是final的，也就是不允许继承。(子类可以覆盖父类的方法，有可能改变不可变性)。

Java SDK中很多类都具备不可变性。如String、Integer、Long、Double等基础类型的包装类都具备不可变性，这些对象的线程安全性都是靠不可变性来保证的。这些类的声明、属性、方法都严格遵守不可变类的三点要求：类和属性都是final的，所有方法均是只读的。

String这个类以及它的属性value[]都是final的；replace()方法的实现，没有修改value[]，而是将替换后的字符串作为返回值返回了。

public final class String {
    private final char value[];
    //字符替换
    String replace(char oldChar, char newChar) {
        //无需替换，直接返回this
        if(oldChar == newChar) {
            return this;
        }
        int len = value.length;
        int i = -1;
        //avoid getfield opcode
        char[] val = value;
        //定位到需要替换的字符位置
        while(++i < len) {
            if(val[i] == oldChar) {
                break;
            }
        }
        //未找到oldChar，无需替换
        if(i >= len) {
            return this;
        }
        /**
        * 创建一个buf[]
        * 用来保存替换后的字符串
        */
        char buf[] = new char[len];
        for(int j = 0; j < i; j++) {
            buf[j] = valu[j]
        }
        while(i < len) {
            char c = val[i];
            buf[i] = (c == oldChar) ? newChar : c;
            i++;
        }
        //创建一个新的字符串返回
        //原字符串不会发生任何变化
        return new String(buf, true);
    }
}

如果具备不可变性的类，需要提供类似修改的功能，就创建一个新的不可变对象，这是与可变对象的一个重要区别，可变对象往往是修改自己的属性。

所有的修改操作都创建一个新的不可变对象，创建的对象太多，太浪费内存。

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

享元模式(Flyweight Pattern)。利用享元模式可以减少创建对象的数量，从而减少内存占用。Java语言里面的Long、Integer、Short、Byte等这些基本数据类型的包装类都用到了享元模式。

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

Long这个类并没有照搬享元模式，Long内部维护了一个静态的对象池，仅缓存了[-128,127]之间的数字，这个对象池在JVM启动的时候就创建好了，而且这个对象池一直都不会变化，也就是说它是静态的。之所以采用这样的设计，是因为Long这个对象的状态共有2^64种，实在太多，不宜全部缓存，而[-128,127]之间的数字利用率最高。

//valueOf()方法利用了LongCache这个缓存
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);
    }
}

并发基础理论中”Integer和String类型的对象不适合做锁”，其实基本上所有的基础类型的包装类都不适合做锁，因为它们内部用到了享元模式，这会导致看上去私有的锁，其实是共有的。

//本意是A用锁al，B用锁bl，
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的，并不能保证不可变性；
不可变对象也需要正确发布。

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

//Bar的属性foo虽然是final的，
//依然可以通过setAge()方法来设置foo的属性age
class Foo {
    int age = 0;
    int name = "abc";
}
final class Bar {
    final Foo foo;
    void setAge(int a) {
        foo.age = a;
    }
}

正确的发布不可变对象。不可变对象虽然是线程安全的，但是并不意味着引用这些不可变对象的对象就是线程安全的。

//Foo具备可不变性，线程安全，但是类Bar并不是线程安全的，
//类Bar中持有对Foo的引用foo
//对foo这个引用的修改在多线程中并不能保证可见性和原子性
final class Foo {
    final int age = 0;
    final int name = "abc";
}
//Foo线程安全，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 IllegalArqumentException();
            }
            WMRange nr = new WMRange(v, or.lower);
            if(rf.compareAndSet(or, nr)) {
                return;
            }
        }
    }
}

总结

Java语言里面的String和Integer、Long、Double等基础类型的包装类都具备不可变性，这些对象的线程安全性都是靠不可变性来保证的。Immutability模式是最简单的解决并发问题的方法。

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