chapter04_对象的组合_4_在现有的线程安全类中添加功能

很多情况下应该重用现有的类, 添加自定义的功能, 此时需要在__不破坏线程安全性__的情况下添加新的操作

(1) 方法一: 直接修改原始的类

优点: 同步策略仍然处于同一个源代码文件中, 更容易理解和维护

缺点: 常常无法修改源代码

(2) 方法二: 扩展这个类

同步策略分布到了各个文件中, 并且要确定的得知基类的同步策略

示例

  @ThreadSafe
  public class BetterVector<E> extends Vector<E> {

      // When extending a serializable class, you should redefine serialVersionUID
      static final long serialVersionUID = -3963416950630760754L;

      public synchronized boolean putIfAbsent(E x) {

          boolean absent = !super.contains(x);
          if (absent) {
              super.add(x);
          }

          return absent;
      }
  }

(3) 方法三: 客户端加锁机制

扩展类的功能, 但不是扩展类本身, 而是将扩展代码放入__辅助类__中

客户端加锁: 对于使用某个对象X的客户端代码, 使用__X本身用于保护其状态的锁__来保护这段客户代码

所以, 使用客户端加锁方式, 必须从源码中找到X使用的是哪一个锁

示例

错误示例

  @NotThreadSafe
  class BadListHelper<E> {

      public List<E> list = Collections.synchronizedList(new ArrayList<E>());

      public synchronized boolean putIfAbsent(E x) {

          boolean absent = !list.contains(x);

          if (absent) {
              list.add(x);
          }

          return absent;
      }
  }

正确示例

  @ThreadSafe
  class GoodListHelper<E> {

      public List<E> list = Collections.synchronizedList(new ArrayList<E>());

      public boolean putIfAbsent(E x) {

          synchronized (list) {
      
              boolean absent = !list.contains(x);

              if (absent) {
                  list.add(x);
              }

              return absent;
          }
      }
  }

正确示例和错误示例的区别在于使用锁的不同, 深入Collections.synchronizedList的源码, 会发现它使用的锁就是Collections.synchronizedList对象本身, 所以辅助类中也要使用Collections.synchronizedList本身作为锁

和方法二一样, 客户端加锁方式也存在同步策略分布在各个类中的问题, 这样当底层源码的同步策略改变时可能会不稳。

(4) 方法四: 组合

使用Java监视器模式, 对内部的对象完全由类本身提供的锁保护, 不管底层的类是否线程安全

示例

  @ThreadSafe
  public class ImprovedList<T> implements List<T> {

      private final List<T> list;

      public ImprovedList(List<T> list) {
          this.list = list;
      }

      public synchronized boolean putIfAbsent(T x) {

          boolean contains = list.contains(x);
          if (contains) {
              list.add(x);
          }

          return !contains;
      }

      // Plain vanilla delegation for List methods.
      // Mutative methods must be synchronized to ensure atomicity of putIfAbsent.

      public synchronized boolean addAll(Collection<? extends T> c) {
          return list.addAll(c);
      }

      public synchronized boolean addAll(int index, Collection<? extends T> c) {
          return list.addAll(index, c);
      }

      public synchronized boolean removeAll(Collection<?> c) {
          return list.removeAll(c);
      }

      public synchronized boolean retainAll(Collection<?> c) {
          return list.retainAll(c);
      }

      public synchronized void clear() {
          list.clear();
      }

      public synchronized boolean add(T e) {
          return list.add(e);
      }

      public synchronized boolean remove(Object o) {
          return list.remove(o);
      }


      public int size() {
          return list.size();
      }

      public boolean isEmpty() {
          return list.isEmpty();
      }

      public boolean contains(Object o) {
          return list.contains(o);
      }

      public Iterator<T> iterator() {
          return list.iterator();
      }

      public Object[] toArray() {
          return list.toArray();
      }

      public <T> T[] toArray(T[] a) {
          return list.toArray(a);
      }

      public boolean containsAll(Collection<?> c) {
          return list.containsAll(c);
      }

      public boolean equals(Object o) {
          return list.equals(o);
      }

      public int hashCode() {
          return list.hashCode();
      }

      public T get(int index) {
          return list.get(index);
      }

      public T set(int index, T element) {
          return list.set(index, element);
      }

      public void add(int index, T element) {
          list.add(index, element);
      }

      public T remove(int index) {
          return list.remove(index);
      }

      public int indexOf(Object o) {
          return list.indexOf(o);
      }

      public int lastIndexOf(Object o) {
          return list.lastIndexOf(o);
      }

      public ListIterator<T> listIterator() {
          return list.listIterator();
      }

      public ListIterator<T> listIterator(int index) {
          return list.listIterator(index);
      }

      public List<T> subList(int fromIndex, int toIndex) {
          return list.subList(fromIndex, toIndex);
      }
  }

所有需要同步的方法都使用ImprovedList本身的锁, 而不必在意封装对象的同步策略

同步策略应该文档化

定义好

(1) 哪些变量为volatile

(2) 哪些变量用锁保护

(3) 哪些变量必须不可变或者线程封闭

(4) 哪些操作必须是原子操作

等……