java - 与 volatile 、不可变对象(immutable对象)及其用于实现同步相关的疑问

Question

我正在阅读《Java并发实践》一书，读了几页后就产生了一些疑问。

1) Voltile 具有非预设数据类型: 私有(private)不稳定的学生； 当涉及非前置数据类型时， volatile 的意义是什么？ (我认为在这种情况下，仅认为 Strudent 对象 s 当前指向的内容肯定对所有线程可见，并且一个线程 A 可能修改了 Student 的某些内部成员，而这对其他线程不可见。我对吗？ ？)

2) 即使内部成员没有声明为final，变量是否可以是不可变的？ 例如:

Class  A {

    private Set<String> s = new Set();
    public A() {
        s.add("Moe");
        s.add("Larry");
        s.add("Curly");
    }
} 

在这个类中，我们是否需要将 Set 设置为 Final 以使其不可变，或者这个类仍然是不可变的？ (因为即使在这种情况下，我们也无法在创建对象后更改对象的状态)。

3) 书中有一个例子展示了如何结合使用 volatile 和不可变类来获得同步。在提出这个问题之前，我还有一个疑问。 假设有这样的函数:

private Student s = new Student;

void func() {
    s.func2();      // 1
    if(s.isPossible()) { //2
        s = new Student(); //3      
    }
}

a)func2() 访问 s 的内部成员。现在考虑线程 A 在执行第 1 行后进入 func2，线程 B 同时用新对象重新分配 s。当线程 A 恢复时 它会使用新对象还是旧对象？ (假设 s 最初指向内存位置 100(旧对象)，在分配新对象后，它开始指向 200(新对象) 那么当线程 A 恢复时，它将访问地址 100 或地址 200)。

b)如果我将 s 设为 volatile ，会对上述情况产生任何影响吗？

4.)这是最后一个

@Immutable
class OneValueCache {
    private final BigInteger lastNumber;
    private final BigInteger[] lastFactors;
    public OneValueCache(BigInteger i,
    BigInteger[] factors) {
        lastNumber = i;
        lastFactors = Arrays.copyOf(factors, factors.length);
    }
    public BigInteger[] getFactors(BigInteger i) {
        if (lastNumber == null || !lastNumber.equals(i))
            return null;
        else
            return Arrays.copyOf(lastFactors, lastFactors.length);
    }
}

@ThreadSafe
public class VolatileCachedFactorizer implements Servlet {
    private volatile OneValueCache cache = new OneValueCache(null, null);
    public void service(ServletRequest req, ServletResponse resp) {
        BigInteger i = extractFromRequest(req);
        BigInteger[] factors = cache.getFactors(i); // Position A

        if (factors == null) {
            factors = factor(i);
            cache = new OneValueCache(i, factors); // Position B
        }
        encodeIntoResponse(resp, factors);
    }
}

根据书本类“VolatileCachedFactorizer”是线程安全的。这是我为什么它是线程安全的推理(如果我错了，请纠正我。)Positin A 和 Position B 是 可疑的立场。

位置A:由于缓存指向不可变对象(immutable对象)，任何函数调用都是安全的(对吗？)。

位置 B:它可能有两个问题

a) 线程发现缓存未正确初始化。在这种情况下不可能，因为保证不可变对象(immutable对象)被正确初始化(对吗？)。

b)新分配的对象对其他线程不可见。这种情况是不可能的，因为缓存是 volatile 的(对吗？)。

但有可能线程 A 调用 getFactors() 并且其他线程 B 重新分配缓存，在这种情况下 A 将继续看到旧对象(对吗？)

Answer 1

1. 是的； volatile 仅适用于它所应用的引用。

2. 不；最终字段恰好指向的对象不会神奇地变得不可变。
   具有可变非公共(public)成员的对象只有在这些成员永远不能改变的情况下才是不可变的。 (显然)