1_基础知识_chapter03_对象的共享_4_不变性

不可变对象

(1) 满足条件

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

2° 对象的所有域都是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也能保证线程安全。