Java并发编程实战-3基础知识_对象的组合

Publish: 2018/7/23   

• Java 并发编程实战

设计线程安全的类

在设计线程安全类的过程中，需要包含以下三个基本要素：

• 找出构成对象状态的所有变量。
• 找出约束状态变量的不变性条件。
• 简历对象状态的并发访问管理策略

收集同步需求

如果不了解对象的不变性条件与后验条件，那么就不能确保线程安全性。要满足在状态变量的有效值或状态转换上的各种约束条件，就需要借助于原子性于封装性。

依赖状态的操作

如果在某个操作中包含有基于状态的先验条件，那么这个操作就称为依赖状态的操作。

一种更简单的方法是通过现有库中的类(例如阻塞队列[Blocking Queue]或信号量[Semaphore]来实现依赖状态的行为)。

状态的所有权

在Java中，所有权属于类设计中的一个要素。

为了防止多线程在并发访问同一个对象时产生的相互干扰，这些对象应该要么是线程安全的对象，要么是事实不可变的对象。或者由锁来保护的对象。

实例封闭

将数据封装在对象内部，可以将数据的访问限制在对象的方法上，从而更容易确保线程在访问数据时总能持有正确的锁。

    //通过封闭机制来确保线程安全
    //如果Person类是可变的，那么在访问从PersonSet中获得的Person对象时，还需要额外的同步。
    @ThreadSafe
    public class PersonSet{
        @GuardedBy("this")
        private final Set mySet = new HashSet<>();

        public synchronized void addPerson(Person p){
            mySet.add(p);
        }

        public synchronized boolean containsPerson(Person p){
            return mySet.contains(p);
        }
    }

Java类库提供了包装器工厂方法(例如Collections.synchronizedList以及其它类似方法)，使得这些非线程安全的类(例如ArrayList和HashMap)可以在多线程环境中安全地使用。

• 工厂方法通过“装饰器(Decorator)”模式将容器类封装在一个同步的包装器对象中，将接口中的每个方法都实现为同步方法。
• 只要包装器对象拥有对底层容器对象的唯一引用(即把底层对象封闭在包装器中)，它就是线程安全的。
• Javadoc中指出，对底层容器对象的所有访问必须通过包装器来进行。

封闭机制更易于构造线程安全的类，因为当封闭类的状态时，在分析类的线程安全性时就无须检查整个程序。

Java监视器模式

遵循Java监视器模式的对象会把对象的所有可变状态都封装起来，由对象自己的内置锁来保护。

    // 通过一个私有锁来保护状态
    public class PrivateLock{
        private final Object myLock = new Object();
        @GuardedBy("myLock") Widget widget;

        void someMethod(){
            //私有的锁对象可以将锁封装起来，是客户代码无法得到锁
            synchronized(myLock){
                //访问或修改Widget的状态
            }
        }
    }

示例：车辆追踪

    @ThreadSafe
    public class MonitorVehicleTracker{
        @GuardedBy("this")
        private final Map locations;

        public MonitorVehicleTracker(Map locations){
            this.locations = deepCopy(locations);
        }

        public synchronized Map getLocations(){
            return deepCopy(locations);
        }

        public synchronized void setLocation(String id,int x,int y){
            MutablePoint loc = locations.get(id);
            if(loc == null)
                throw new IllegalArgumentException("No such ID" + id);
            loc.x=x;
            loc.y=y;
        }

        private static Map deepCopy(Map m){
            Map result = new HashMap();
            for(String id:m.keySet())
                result.put(id,new MutablePoint(m.get(id)));
            return Collections.unmodifiableMap(result);
        }
    }

    @NotThreadSafe
    public class MutablePoint{
        public int x,y;

        public MutablePoint(){x=0,y=0;}
        public MutablePoint(MutablePoint p){
            this.x=p.x;
            this.y=p.y;
        }
    }

当车辆容器非常大的情况下将极大的降低性能。deepCopy将执行较长时间，tracker的内置锁将被占用。造成车辆的实际位置发生了变化，但返回的信息却保持不变。

线程安全性的委托

示例：基于委托的车辆追踪器

    @Immutable
    public class Point{
        public final int x,y;
        public Point(int x,int y){
            this.x=x;
            this.y=y;
        }
    }

    /*如果使用MutablePoint而不是Point，就会破坏封装性，
      因为getLocations会发布一个指向可变状态的引用，而这个引用不是线程安全的。
     */
    @ThreadSafe
    public class DelegatingVehicleTracker{
        private final ConcurrentMap locations;
        private final Map unmodifiableMap;

        public DelegatingVehicleTracker(Map points){
            locations = new ConcurrentHashMap(points);
            unmodifiableMap = Collections.unmodifiableMap(locations);
        }

        public Map getLocations(){
            return unmodifiableMap;
        }

        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);
        }

        //如果需要一个不发生变化的车辆视图,浅拷贝，只复制Map结构，不复制内容
        public Map getLocations(){
            return Collections.unmodifiableMap(new HashMap(locations));
        }
    }

独立的状态变量

组合而成的类并不会在其包含的多个状态变量上增加任何不变性条件。

    public class VisualComponent{
        /*CopyOnWriteArrayList是线程安全的链表
          keyListener和mouseListeners彼此独立，VisualComponent可以将其线程安全性委托给这两个线程安全的监听器列表。
         */
        private final List keyListeners = new CopyOnWriteArrayList<>();
        private final List mouseListeners = new CopyOnWriteArrayList<>();

        public void addKeyListener(KeyListener listener){
            keyListeners.add(listener);
        }

        public void addMouseListener(MouseListener listener){
            mouseListeners.add(listener);
        }

    }

当委托失效时

如果一个类是由多个独立且线程安全的状态变量组成，并且在所有的操作中都不包含无效状态转换，那么可以将线程安全性委托给底层的状态变量。

发布底层的状态变量

如果一个状态变量是线程安全的，并且没有任何不变性条件来约束它的值，在变量的操作上也不存在任何不允许的状态转换，那么就可以安全地发布这个变量。

在现有的线程安全类中添加功能

• 通常，应该优先选择重用Java类库包中现有的类而不是创建新的类。
• 扩展类优于扩展方法

客户端加锁机制

将扩展代码放入一个”辅助类中”。

• 客户端加锁会破坏同步策略的封装性。

• 扩展会破坏实现的封装性

   @ThreadSafe
   public class ListHelp{
       public List list= Collections.synchronizedList(new ArrayList());
  
       /*在putIfAbsent上添加synchronized不能实现线程安全
         list上的锁和ListHelp上的锁不是一个锁。
        */
       public boolean putIfAbsent(E x){
           synchronized(list){
               boolean absent =!list.contains(x);
               if (absent)
                   list.add(x);
               return absent;
           }
       }
   }
  

组合

当为现有的类添加一个原子操作时，有一种更好的方法：组合。

    //通过组合实现"若没有则添加"
    @ThreadSafe
    public class ImprovedList implements List {
        private final List list;

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

        public synchronized boolean putIfAbsent(T x) {
            boolean contains = list.contains(x);
            if (contains)
                list.add(x);
            return !contains;
        }

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

将同步策略文档化

在文档中说明客户代码需要了解的线程安全性保证，以及代码维护人员需要了解的同步策略。