volatile+不可变的holder对象=线程安全？

Question

public class VolatileCachedFactorizer extends GenericServlet 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);
    if (factors == null) {             
        factors = factor(i);  //----------> thread A
        cache = new OneValueCache(i, factors);  //---------> thread B
    }
    encodeIntoResponse(resp, factors);
  }   
 }

public class OneValueCache {

  private final BigInteger lastNum;
  private final BigInteger[] lastFactors;

  public OneValueCache(BigInteger i, BigInteger[] lastFactors){
    this.lastNum = i;
    this.lastFactors = lastFactors;
  }

  public BigInteger[] getFactors(BigInteger i){
    if(lastNum == null || !lastNum.equals(i))
        return null;
    else
        return Arrays.copyOf(lastFactors, lastFactors.length);
  }

}

类OneValueCache是不可变的。但是我们可以更改变量缓存的引用。

但我不能理解为什么VolateCachedFactorizer类是线程安全的。

对于两个线程（线程A和线程B)，如果线程A和线程B同时到达factors==null，那么两个线程A和B都将尝试创建OnEvalueCache。然后线程A到达factors=factor(i)而线程B同时到达cache=new OneValueCache(i,factors)。然后线程A将创建一个OnEvalueCache，它覆盖threadB创建的值（OneValueChange是不可变的，但是可以更改对变量缓存的引用）。

Answer 1

因此，两个线程计算因子（一个为67，另一个为89)，然后将它们的结果存储到cache变量中。最后一个设置变量的线程获胜。假设第一个线程是最后一个将其因子存储在缓存中的线程。因此，高速缓存包含67的因子。

如果后续执行请求67的因子，它将从缓存中获取这些因子（因为缓存不是空的，并且包含67的因子）。如果它请求另一个数的因子，它不会从缓存中获取它们，将因此计算这些因子，并将它们存储在缓存中，希望下面的请求将请求相同个数的因子。

不能保证两个线程不会从相同的数字计算因子。此代码提供的唯一保证是，如果缓存当前包含所请求的数字的因子，则将返回这些缓存的因子（而不是其他数字的因子或数据竞争导致的不一致数据）