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

2023-12-24 18:51:05

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

文章来源:https://blog.csdn.net/jia970426/article/details/135183736
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。