不变性（Immutability）模式

1. 不变性（Immutability）模式

1.1. 不变性模式的概念

定义：对象一旦被创建，其内部状态就不再发生变化，也即“只读无写”，不会出现并发写的问题，自然线程安全。

适用场景：只读共享数据场景，是并发编程中最简单直接的线程安全保障方案。

不变性模式的作用：

不变性模式的实际作用不是为了“能不能安全读”，而是为了简化并发程序设计。如果对象不可变：

• 不需要加锁
• 不需要 volatile
• 不用担心可见性问题
• 不用写复杂的同步控制逻辑

只需保证创建时一次写入，之后多线程随便读即可。

不变性模式不是为了实现线程安全，而是为了“让线程安全成为默认”，并从语言/设计层面强制杜绝修改，从而简化并发程序的设计。

1.2. 实现不变性模式

1. Java 实现方式

public final class Person {private final String name;private final int age;public Person(String name, int age) {this.name = name;this.age = age;}public Person withAge(int newAge) {return new Person(this.name, newAge);}public String getName() { return name; }public int getAge() { return age; }
}

2. Python 实现方式

from dataclasses import dataclass@dataclass(frozen=True)
class Person:name: strage: intp1 = Person("Alice", 30)
p2 = Person(p1.name, 31)  # 通过创建新对象实现“修改”

3. Go 实现方式（没有语言级别支持，只能靠规范）

type Person struct {name stringage  int
}// 提供只读 getter
func (p Person) Name() string {return p.name
}// 修改返回新对象
func (p Person) WithAge(newAge int) Person {return Person{name: p.name, age: newAge}
}

Immutability 模式注意事项

1. final 属性 ≠ 不可变

如果类的属性是对象，即使属性用 final 修饰，属性本身不变，属性引用的对象内容仍然可能被更改。

正确方式：确保引用对象也不可变。

class Foo {int age;
}final class Bar {final Foo foo;  // Foo 是可变的
}

2. 不可变对象也需要正确发布

• 不可变对象虽然线程安全，但持有不可变对象的引用不一定是线程安全的。
• 若引用在多个线程间共享，需使用 volatile 或原子类保证可见性/原子性。

原子类示例：

AtomicReference<WMRange> rf = new AtomicReference<>(new WMRange(0, 0));

1.3. 享元模式（Flyweight Pattern）

概念

• 定义：通过复用相同对象，避免重复创建，降低内存消耗。
• 本质：对象池（缓存）。
• 关键点：

• • 对象不可变（否则复用会有副作用）
  • 对象的创建要通过工厂/缓存控制

1. Java 中的应用

Java 的 Long.valueOf() 使用享元模式缓存了 [-128,127] 范围的数值：

static final Long cache[] = new Long[256];static {for (int i = 0; i < cache.length; i++) {cache[i] = new Long(i - 128);}
}Long.valueOf(long l) {if (l >= -128 && l <= 127)return LongCache.cache[(int) l + 128];return new Long(l);
}

锁问题示例：

Long al = Long.valueOf(1);
Long bl = Long.valueOf(1);
// al == bl，锁是同一把 → 不安全！

2. Python 中的享元模式

Python 的 int 和 str 对象也使用了享元机制。

a = 100
b = 100
print(a is b)  # True，因为缓存了 [-5, 256] 的整数

自定义享元：

class FlyweightFactory:_cache = {}@staticmethoddef get(value):if value not in FlyweightFactory._cache:FlyweightFactory._cache[value] = HeavyObject(value)return FlyweightFactory._cache[value]

3. Go 中的享元模式

Go 中没有自动享元机制，但可手动实现对象池：

var pool = make(map[string]*User)func GetUser(name string) *User {if u, ok := pool[name]; ok {return u}u := &User{name: name}pool[name] = ureturn u
}

• Go 标准库中也提供了对象池工具：sync.Pool（并非享元，但类似概念）