上一篇文章，我们介绍了如何利用二阶段停止协议进行优雅停止线程和线程池，本篇介绍在并发编程中数据安全性，我们知道针对于数据的操作，读和写(添加、删除、修改), 在并发线程读写的时候，变量不加锁的情况下，一定会有线程安全问题。但是如果变量只有读操作，多个线程就不存在资源的竞争操作，因为变量 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 cachereturn 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模式，利用享元模式解决不可变性的重复对象的问题，在多线程编程的时候，我们需要首先考虑是否数据是否不可变，如果不可变，就简单了，如果不行在使用别的设计模式来解决数据安全问题。
在分布式系统中，有无状态服务，就是不存储数据，这种方式可以很好的无限水平拓展，当然也就是有对象的无状态对象，类似于函数式编程，我们只需要输入输出，不改变数据。