利用对象限制和委托构建线程安全的类(java并发编程实战第四章内容)

最新推荐文章于 2023-12-17 19:50:18 发布

哈哈哈哈哈哈哈111

最新推荐文章于 2023-12-17 19:50:18 发布

阅读量449

点赞数

分类专栏： java多线程文章标签： java 线程安全委托对象组合

java多线程专栏收录该内容

22 篇文章 0 订阅

订阅专栏

设计线程安全的类需要考虑:

1. 确定组成对象状态的变量.

2. 确定约束对象状态的不变式.

3. 建立并发访问对象状态的规则.

后置条件: 由于某些变量的取值是有限制范围的, 改变状态变量之后需要检查改变后的状态是否合法. 后置条件要求进行额外的同步. 比如一个计数器, 当前的值为17, 那么进行一次操作之后其取值只能是18, 其他值都是非法的.

前置条件: 需要满足一定的条件操作才能继续进行. 多线程环境下, 可以使用内置的wait和notify机制, 在条件满足时通知另一个线程继续往下执行. 也可以使用阻塞队列, 信号量等实现.

对象限制

借助封装, 可以将对象限制在类范围内(作为类的私有成员), 方法内部(作为方法的局部变量), 或者线程范围内(只能在特定线程中访问该对象).

将对象限制在类范围内的例子:

    Java代码   
    
  
 public class PersonSet {   
     private final Set<Person> mySet = new HashSet<Person>();   
   
     public synchronized void addPerson(Person p) {   
         mySet.add(p);   
     }   
   
     public synchronized boolean containsPerson(Person p) {   
         return mySet.contains(p);   
     }   
 }   

mySet对象不是线程安全的, 但是将mySet对象限制在PersonSet类中, 并通过synchronized同步所有访问mySet对象的方法, 而且mySet对象没有逃逸出PersonSet类范围, PersonSet就是一个线程安全的类.

由上面的例子可知, 受限的对象不能逃逸出所在的范围是非常重要的.

另一个例子是java.util.Collections类提供的一些静态方法, 比如Collections.synchronizedList(List<T> list)方法:

    Java代码   
    
  
 class SynchronizedList<E> extends SynchronizedCollection<E> implements List<E> {  
     static final long serialVersionUID = -7754090372962971524L;  
   
     final List<E> list;  
   
     SynchronizedList(List<E> list) {  
         super(list);  
         this.list = list;  
     }  
   
     SynchronizedList(List<E> list, Object mutex) {  
         super(list, mutex);  
         this.list = list;  
     }  
   
     public boolean equals(Object o) {  
         synchronized (mutex) {  
             return list.equals(o);  
         }  
     }  
   
     public int hashCode() {  
         synchronized (mutex) {  
             return list.hashCode();  
         }  
     }  
   
     public E get(int index) {  
         synchronized (mutex) {  
             return list.get(index);  
         }  
     }  
     // ....  
 }  

可以看出SynchronizedList是对List的包装. SynchronizedList所有的方法都使用同一把锁mutex进行同步. 所以SynchronizedList是一个线程安全的类. 但是前提是被包装的list对象不能再直接使用, 必须通过synchronizedList(List<T> list)返回的对象进行访问(开发者必须遵循这样的约定, 否则线程安全就被破坏了), 也就是防止list对象逃逸出SynchronizedList类的范围.

委托线程安全. 先看一个例子:

    Java代码   
    
  
 public class DelegatingVehicleTracker {  
     private final ConcurrentMap<String, Point> locations;   
   
     public DelegatingVehicleTracker(Map<String, Point> points) {   
     // 构造map的concurrent视图  
         locations = new ConcurrentHashMap<String, Point>(points);   
     }   
   
     public Map<String, Point> getLocations() {   
         // 返回map的unmodifiable视图  
         return Collections.unmodifiableMap(locations);   
     }   
   
     public Point getLocation(String id) {   
         return locations.get(id);   
     }   
   
     public void setLocation(String id, int x, int y) {   
         if (locations.replace(id, new Point(x, y)) == null)   
             throw new IllegalArgumentException(   
                 "invalid vehicle name: " + id);   
     }  
   
     /** 
      * 这是一个不可变类 
      */  
     public class Point {   
         public final int x, y;   
         public Point(int x, int y) {   
             this.x = x;   
             this.y = y;   
         }   
     }  
 }  

DelegatingVehicleTracker只有一个状态变量: locations. locations是一个ConcurrentMap对象, 也就是说locations是线程安全的. 而且locations对象被限制在DelegatingVehicleTracker类范围内. 因此可以说, DelegatingVehicleTracker是一个线程安全的类因为locations是线程安全的. 换一种说法, DelegatingVehicleTracker将线程安全的责任委托给了locations对象.

在构造函数里, 利用points的concurrent视图初始化locations. concurrent视图不同于synchronized视图, synchronized视图只是包装了一层同步, 方法的调用还有由原有的Map对象负责的, 因此JDK文档特别要求不能在外部继续调用原有Map的方法, 所以线程安全来源于约定, 如果开发者没有遵循约定, 线程安全就被破坏了. 但是concurrent视图并非如此, concurrent视图是对原有Map的浅拷贝, 也就是会遍历原有Map, 取出其中的每一个键值对, 然后将取出的键值对存入concurrent视图中. 因此concurrent视图仅和原有的Map共享了键和值的引用, 而由于Map的value(Point对象)是不可变的, 在外部直接调用原有的Map的任何方法, 都不会对concurrent视图造成影响.

我们可以总结出这样的规则: 如果类只包含一个状态变量, 那么类是否是线程安全的, 取决于该状态变量是否是线程安全的.

如果类中存在多个状态变量时, 委托规则是否仍然成立呢? 如下:

    Java代码   
    
  
 public class VisualComponent {   
     private final List<KeyListener> keyListeners   
         = new CopyOnWriteArrayList<KeyListener>();   
     private final List<MouseListener> mouseListeners   
         = new CopyOnWriteArrayList<MouseListener>();   
   
     public void addKeyListener(KeyListener listener) {   
         keyListeners.add(listener);   
     }   
   
     public void addMouseListener(MouseListener listener) {   
         mouseListeners.add(listener);   
     }   
   
     public void removeKeyListener(KeyListener listener) {   
         keyListeners.remove(listener);   
     }   
   
     public void removeMouseListener(MouseListener listener) {   
         mouseListeners.remove(listener);   
     }   
 }  

CopyOnWriteArrayList是ArrayList的线程安全的变体, keyListeners和mouseListeners是线程安全的对象, 而且keyListeners和mouseListeners是相互独立的, 所以VisualComponent也是线程安全的. 当状态变量之间不是相互独立的时候情况又如何呢? 如:

    Java代码   
    
  
 public class NumberRange {   
     // INVARIANT: lower <= upper   
     private final AtomicInteger lower = new AtomicInteger(0);   
     private final AtomicInteger upper = new AtomicInteger(0);   
   
     public void setLower(int i) {   
         // Warning -- unsafe check-then-act   
         if (i > upper.get())   
             throw new IllegalArgumentException(   
                     "can't set lower to " + i + " > upper");   
         lower.set(i);   
     }   
   
     public void setUpper(int i) {   
         // Warning -- unsafe check-then-act   
         if (i < lower.get())   
             throw new IllegalArgumentException(   
                     "can't set upper to " + i + " < lower");   
         upper.set(i);   
     }   
   
     public boolean isInRange(int i) {   
         return (i >= lower.get() && i <= upper.get());   
     }   
 }   

NumberRange类的状态变量lower和upper都是线程安全的对象, 但是lower和upper不是相互独立的, 两者需要满足不变式约束: lower <= upper. 假设lower和upper分别是0和10, 此时2个不同的线程同时调用setLower(5)和setUpper(4), 在某些不幸的时间点这2个方法的前置条件检查都能通过, 这就造成不变式约束不再成立. 因此NumberRange类不是线程安全的.

总结: 如果类中的状态变量之间是相互独立的, 那么线程安全的责任就可以委托给状态变量: 类是否线程安全, 取决于所有状态变量是否线程安全.