java并发编程笔记day04

以你之姓@ 2022-06-09 13:18 205阅读 0赞

## 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来构建一个机动车追踪器，它发布了底层的可变状态，缺不破话线程的安全性。

@ThreadSafe
    public 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 的做法可能就不正确了