java并发编程笔记day04

4.3 委托线程安全

4.3.1 范例：试用委托的机动车追踪器

public class DelegatingVehicleTracker {    private final ConcurrentMap<String,Point> locations;    private final Map<String,Point> unmodifiableMap;    public DelegatingVehicleTracker(Map<String, Point> points) {        locations = new ConcurrentHashMap<String,Point>(points);        unmodifiableMap = Collections.unmodifiableMap(locations);    }    public Map<String,Point> getLocations(){        return unmodifiableMap;    }    public Point getLocation(String id ){        return locations.get(id);    }    public void setLocaltion(String id, int x, int y ){        if (locations.replace(id,  new Point(x, y)) == null ) {            throw new IllegalArgumentException("invilad vehicle name :"+id);        }    }}

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

我们在这里对VehicleTracker 类进行了略微的改变：基于监听器的代码返回localtion的快照，基于委托的代码则返回一个不可变的，但是现场的localtion视图。

如果需要一个不可变的瞬时视图，getLocaltion可以返回一个localtions的Map的灰拷贝，只复制对象的引用，因此复制的对象与原始的对象是同一个对象，相反深拷贝复制的是对象的所有成员变量，因此复制的对象与原始的对象不是一个对象。因为Map的内容是不变的，因此需要复制的只有map的结构而不包括它的内容，如下代码所示：

public Map<String, Point> getLocaltions(){        return Collections.unmodifiableMap(                                new HashMap<String,Point>(locations));    }

4.3.2 非状态依赖变量

目前为止，我们在委托实例中仅仅委托了一个单一的 线程安全的状态变量。我们也可以将线程安全委托到多个隐含的变量上去，只要这些变量彼此都是独立的，这意味着组合对象并未增加任何涉及多个状态变量的不变约束。

委托线程安全到多个底层的状态变量：

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

在VisualComponent 类中，我们的每个list都是线程安全的，而且不存在哪个不变约束会增加一个状态与另一个状态间的耦合，所以VisualComponent 可以将它的线程安全委托到keyListeners 和mouseListeners 上。

4.3.3 当委托无法胜任时

如果像下面代码使用两个AtomicInteger管理NumberRange的状态，而且受到一个额外的约束条件–第一个数小于或等于第二个数。
NumberRange 是线程不安全的，因为它没有保护好用于约束lower和uper的不变约束。setUpper和setLower试图保护不变约束，但是明显办不到。setUpper和setLower都是先检查后运行的操作，但是它们没有适当的加锁以保证其原子性。

假设初始为（0,10） 当一个线程调用setlower（6） 另一个线程调用setupper（4）此时并发执行，先检查的条件都是满足的，那么执行之后的数据为（6,4）一个无效的状态。这个例子很明显的告诉我们虽然AtomicInteger 是线程安全的，但是组合起来就不一定，因为lower和upper不是彼此独立的。

public class NumberRange {    private final AtomicInteger lower = new AtomicInteger(0);    private final AtomicInteger upper = new AtomicInteger(0);    public void setLower(int i) {        if (i > lower.get()) {            throw new IllegalArgumentException("cannot set lower to " + i + ">lower");        }        lower.set(i);    }    public void setUpper(int i) {        if (i < upper.get()) {            throw new IllegalArgumentException("cannot set upper to " + i + ">upperr");        }        upper.set(i);    }    public boolean isInRange(int i) {        return (i >= lower.get() && i <= upper.get());    }}

4.3.4 发布底层的状态变量

如果一个类是线程安全的，没有任何不变约束限制它的值，并且没有任何状态转换限制它的操作，那么它可以被安全的发布。
举个例子 ，大栗子 ！QUQ 我们上面的VisualComponent 发布mouseListeners 或者
keyListeners 是安全的，因为VisualComponent 没有对监听器清单的合法状态进行限制，所以把这些域声明为public，或者发布它们，都不会危及到线程的安全。

4.3.5 示例：发布了状态的机动车追踪器

又是一个大栗子。。。啦啦啦。。。
我们构造一个发布了底层状态的版本的机动车追踪器，我们要改变一下接口适应，这次试用可变但线程安全的Point，我们这里的Point提供了一个get函数获得一个包含x，y的二位数组。因为我们如果单独为x，y提供get方法的话那么我们获得的x，y的值可以是在两个坐标上的x，y会导致此时取到的x，y位置上并没有我们的机动车。我们使用SafePoint来构建一个机动车追踪器，它发布了底层的可变状态，缺不破话线程的安全性。

@ThreadSafepublic class SafePoint {    @GuardedBy("this")    private int x,y;    private SafePoint(int[] a){        this(a[0],a[1]);    }    public SafePoint(SafePoint p){        this(p.get());    }    public SafePoint(int x,int y){        this.x= x;        this.y=y;    }    public synchronized int[] get(){        return new int[]{x,y};    }    public synchronized void set(int x,int y){        this.x=x;        this.y=y;    }}

public class PublishingVehicleTracker {    private final Map<String, SafePoint> locations;    private final Map<String, SafePoint> unmodifiableMap;    public PublishingVehicleTracker(Map<String, SafePoint> locations){        this.locations = new ConcurrentHashMap<String,SafePoint>(locations);        this.unmodifiableMap = Collections.unmodifiableMap(this.locations);    }    public Map<String, SafePoint> getLocations(){        return unmodifiableMap;    }    public SafePoint getLocation(String id){        return unmodifiableMap.get(id);    }    public void setLocation(String id ,int x, int y){        if (!locations.containsKey(id)) {            throw new IllegalArgumentException("invalid vehicle name :"+id);        }        locations.get(id).set(x, y);    }}

PublishingVehicleTracker 的线程安全源于它所委托的底层ConcurrentHashMap，不过这次的map的内容是线程安全的可变Point，而非不变的。getlocation返回底层map的不可变拷贝，调用者在其上无法添加或移除车辆，却可以修改返回的map中的safepoint的值来达到修改一辆机动车的位置。map的这一现场特性是否有价值，还是一个缺陷，任然取决于需求。只有PublishingVehicleTracker 对机动车追踪器的合法值没有施加任何额外的约束时，它才是现场安全的。如果我们对location的改变进行判断或者执行一些其他操作，那么PublishingVehicleTracker 的做法可能就不正确了