【并发设计模式】聊聊Immutability模式利用不变性解决并发问题

上一篇文章，我们介绍了如何利用二阶段停止协议进行优雅停止线程和线程池，本篇介绍在并发编程中数据安全性，我们知道针对于数据的操作，读和写(添加、删除、修改), 在并发线程读写的时候，变量不加锁的情况下，一定会有线程安全问题。但是如果变量只有读操作，多个线程就不存在资源的竞争操作，因为变量 i = 10, 多个线程不修改，都读取到的一定是10。

所以Immutability模式就是利用变量只读的方式。对象一创建之后，就不会在修改。

实现不可变性的类

如何实现呢，其实很简单，就是针对的类和属性 添加final 关键词进行修饰。并且只提供只读的方法。

Java中String、Integer 、Double等基础类都是具备不可变性。类和属性都是final，所有方法都是只读的。但是你可能使用过String的替换方法，我们看看源码看是怎么回事。

类和属性都被final修饰。replace 其实是通过内部构件了一个新的char数组。进行操作的。 也就是创建了一个新的不可变对象。

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] = val[j];
    }
    while (i < len) {
      char c = val[i];
      buf[i] = (c == oldChar) ? 
        newChar : c;
      i++;
    }
    // 创建一个新的字符串返回
    // 原字符串不会发生任何变化
    return new String(buf, true);
  }
}

问题： 那么如果频繁创建过多相同的对象，会不会对内存造成影响。又如何解决呢？？

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

这里可能要留一个坑了，那就是什么是享元模式，后边有时间花一篇文章在介绍。
简单一点其实享元模式就是可以共享的单元，目的是达到对象的服用、共享，前提是不可变对象。
将相同的对象只保存一份，可以复用。实现比较简单，就是使用list或者map存储共享的对象。
这里简单说下和单例模式的区别：单例模式是为了保证对象的全局唯一性，享元模式是达到对象的服用。

享元模式工作模式：享元模式其实就是一个对象池，创建的时候，先看池里有没有，没有的话新创建，有的话 直接复用。

我们通过分析Long 可以发现，通过一个静态类 提前创建-128到127之间的数。使用的时候，先查看是否在这个范围，在的话直接使用。Integer类也是大同小异。

    //缓存-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);
        }
    }

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

问题：那么可以使用基础类做一把锁嘛？

    private Integer lockA = new Integer(0);
    private Integer lockB = new Integer(0);

    public static void main(String[] args) throws InterruptedException {
        TestBaseLock t = new TestBaseLock();
        new Thread(()-> { t.lockA();}).start();
        new Thread(()-> { t.lockB();}).start();


        TimeUnit.SECONDS.sleep(100);
    }

    public void lockA () {
        synchronized (lockA) {
            System.out.println("LockA before");
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("LockA after");
        }
    }

    public void lockB ()  {
        synchronized (lockB) {
            System.out.println("LockB before");
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("LockB after");
        }
    }

从执行结果来看的话，发现啊，怎么会lockA 获取锁的同时，lockB也可以获取呢。因为本质就是Integer lockA 和 lockB 共享的是同一个对象。公用一把锁。并不是两把锁。

LockA before
LockB before
LockA after
LockB after

注意点

在实际的编程中，可能A对象内部的对象属性B 和 属性值是C是不可变的，但是对象属性B 可以被修改。 所以我们需要合理评估不可变性的边界在哪里，是否属性对象也需要保证。
如果需要保证就需要加上voliatie保证可见性、如果保证原子性，可以使用原子类进行构建。

class B{
  int age=0;
  int name="abc";
}
final class A {
  final B b;
  final Integer c;
  void setAge(int a){
    c=a;
  }
}

总结

好了，本篇主要介绍了Immutability模式，利用享元模式解决不可变性的重复对象的问题，在多线程编程的时候，我们需要首先考虑是否数据是否不可变，如果不可变，就简单了，如果不行在使用别的设计模式来解决数据安全问题。
在分布式系统中，有无状态服务，就是不存储数据，这种方式可以很好的无限水平拓展，当然也就是有对象的无状态对象，类似于函数式编程，我们只需要输入输出，不改变数据。