chapter03_对象的共享_4_不变性

• 不可变对象

  (1) 满足条件

  1° 对象创建以后状态不能更改

  2° 对象的所有域都是final类型(包括对象的字段也是final)

  3° 对象被正确创建(构造函数中没有发生this引用逸出)

  (2) 不可变对象一定是线程安全的

  (3) 不可变对象的状态可以更新, 更新的方式是通过一个保存新状态的实例来替换原有的不可变对象(例如String, Integer)

• final域

  (1) 如果final域所引用的对象可变, 那么这些被引用的对象是可以修改的

  (2) final域在Java内存模型中有特殊的语义:

  final域能够确保初始化过程的安全性, 从而在共享这些对象时无须同步(保证了可见性)

  (3) 即使一个对象是可变的, 但是可以将某些域声明为final, 减少可能的状态数

  (4) 除非需要更高的可见性, 否则所有的域都应该是private的;

  除非需要某个域真正可变, 否则所有的域都应该是final的

• 一种操作是__将类中的所有的状态变量封装在一起组成一个新的类,这个类写成不可变类的形式, 在原有类中有volatile声明这个新类的对象, 这样如果更新类的状态, 则将这个新类的对象整体进行更新, 无需显式使用synchronized也可以保证线程安全__

  示例

  OneValueCache.java

    @Immutable
    public 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);
            }
        }
    }
  

  VolatileCachedFactorizer.java

    @ThreadSafe
    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);
                cache = new OneValueCache(i, factors);
            }
            encodeIntoResponse(resp, factors);
        }
  
        private void encodeIntoResponse(ServletResponse resp, BigInteger[] factors) {
        }
  
        private BigInteger extractFromRequest(ServletRequest req) {
  
            return new BigInteger("7");
        }
  
        private BigInteger[] factor(BigInteger i) {
  
            // Doesn't really factor
            return new BigInteger[]{i};
        }
    }
  

  VolatileCachedFactorizer原本有两个状态变量: lastNumber和lastFactors。现在把它们抽出来组合成一个不可变类OneValueCache。 OneValueCache是一个不可变类, 因为它完全满足不可变对象的三个条件(注意使用了Arrays.copyOf传出lastFactors避免了状态被改变)。

  现在, 在VolatileCachedFactorizer声明了一个不可变对象cache, 并且用volatile修饰保证了可见性, 需要更改它的状态时则new一个新的OneValueCache对象，这样就做到了无需使用synchronized也能保证线程安全。