Java并发编程实战笔记—— 并发编程3

1、实例封闭

class personset{
    private final Set<Person> myset = new HashSet<Person>();
    
    public void addPersom(Person p){
        myset.add(p);
    }
    
    public boolean containPerson(Person p){
        return myset.contains(p);
    }
}

　　这个类的状态是由HashSet来进行管理的，这里的myset是私有的且并不会逸出，因此HashSer被封闭在personset中，所以如果不对myset进行访问那这个类就是线程安全的，但是由于HashSet并不是线程安全的，所以其add和contains方法都不是线程安全的，所以需要加上锁。

class personset{
    private final Set<Person> myset = new HashSet<Person>();

    public synchronized void addPersom(Person p){
        myset.add(p);
    }

    public synchronized boolean containPerson(Person p){
        return myset.contains(p);
    }
}

　　这样personset的状态完全由它的内置锁保护着，因而它就是一个线程安全的类。

　　这个例子中并未对Person的线程安全性进行假设，如果Person类是可变的，那么从personset中获得Person对象时还需要额外的同步

　　示例：车辆追踪

class MutablePoint{
    private int x;
    private int y;
    public MutablePoint(){
        this.x = 0;
        this.y = 0;
    }
    public MutablePoint(MutablePoint m){
        this.x = m.getX();
        this.y = m.getY();
    }
    public synchronized int getX() {
        return x;
    }

    public synchronized void setX(int x) {
        this.x = x;
    }

    public synchronized int getY() {
        return y;
    }

    public synchronized void setY(int y) {
        this.y = y;
    }
}　　

　　MutablePoint是一个记录车辆坐标的类　　

public class MonitorVehicleTracker {
    private final Map<String, MutablePoint> locations;
    public MonitorVehicleTracker(Map<String,MutablePoint> locations){
        this.locations = deepcopy(locations);
    }
    public synchronized Map<String,MutablePoint> getLocations(){
        return deepcopy(locations);
    }
    public synchronized MutablePoint getLocation(String id)
    {
        //获取要返回的数据
        MutablePoint loc = locations.get(id);
        //创建一个新的对象返回
        return loc == null ? null : new MutablePoint(loc);
    }

    private Map<String, MutablePoint> deepcopy(Map<String, MutablePoint> m ){
        Map<String, MutablePoint> result = new HashMap<String, MutablePoint>();
        for(String id: m.keySet()){
            result.put(id, new MutablePoint(m.get(id)));
        }
        //返回的是一个不可修改的Map
        return Collections.unmodifiableMap(result);
    }
}

　　MonitorVehicleTracker是一个线程安全的追踪器，它所包含的Map对象和可变的MutablePoint都是对外未曾发布的当需要返回车辆的位置的时候，通过MutablePoint的构造函数来复制新的值。

2、线程安全性的委托

　　还可以创建一个不可变的Point类来替换MutablePoint，然后构造一个委托给线程安全的车辆追踪器，我们可以先把数据存储在一个线程安全的ConcurrentHashMap类中。

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

　　这个Point是不可变的，因此它是线程安全，因为不可变的值可以自由的分享和发布，所以在返回location的时候不需要再复制。

public class MonitorVehicleTracker {
    private final ConcurrentHashMapConcurrentHashMap<String,Point> locations;
    private final Map<String, Point> unmodifiableMap;

    public MonitorVehicleTracker(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 unmodifiableMap.get(id);
    }

}

　　这里没有使用明显的同步，所有对状态的访问都由ConcurrentHashMap来管理，创建对象的构造器中先讲数据存储在ConcurrentHashMap类型的对象中，再调用Collections的unmodifibleMap方法将数据传给unmodifiableMap，这个方法返回指定映射的不可修改视图以保证线程安全，这样想要修改unmodifiableMap中的数据（想要修改这个对象的状态），只能通过构造器新建一个对象了。

3、当委托失效时

class NumberRange{
    private final  AtomicInteger lower = new AtomicInteger(0);
    private final  AtomicInteger upper = new AtomicInteger(0);
    public void setLower(int i){
　　　　　//这里是不安全的
        if(i > upper.get()){
            throw new IllegalArgumentException(
                    "can't set lower to " + i + " > upper ");
        }
        lower.set(i);
    }
    public void setUpper(int i){
　　　　　//这里是不安全的
        if(i < lower.get()){
            throw new IllegalArgumentException(
                    "can't set lower to " + i + " > upper ");
        }
        upper.set(i);
    }
    public boolean isInrange(int i ){
        return (i >= lower.get() && i <= upper.get());
    }
}

　　这里的NumberRange并不是线程安全的，setLower和setUpper都是先检查后执行的操作。这里会出现的问题就是如果线程A想要修改了upper为4，但是并没有进行到set这一行，线程B想要修改lower为5是可以通过检查的。结果可能会变成（5，4）。

　　结论就是如果某个类含有复合操作，就像上面这样，仅靠委托并不足以实现线程安全性，在这种情况下，这个类必须提供自己的加锁机制保证这些复合操作都是原子操作，除非整个复合操作都可以委托给状态变量。

4、 客户端加锁机制

class ListHelps<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;
    }
}

　　这里实现的是如果list中没有x则添加x。这里的锁仅仅只是锁住了“如果没有则添加”这个操作，所以如果线程A进行了这个操作，其他线程并不能执行“如果没有则添加”这个操作。但是如果线程A在“其他线程调用另外的方法添加了x”之前已经执行完验证x的存在。总的来说就是putIfAbsent相对于其他list的操作并不是原子性的。

class ListHelps<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;
        }
    }
}

　　上面的代码给出了如何使putIfAbsent相对于其他list的操作变得是原子性的。

5、组合

class ImprovedList<T> implements List<T>{
    private List<T> list;

    public  ImprovedList(List<T> list){
        this.list = list;
    }
    public synchronized  boolean putIfAbsent(T x){
        boolean absent = !list.contains(x);
        if (absent)
            list.add(x);
        return absent;
    }
}

　　这样的组合将存储数据的list，也就是真正代表类的状态的list变量封闭在了ImprovedList中，然后putIfAbsent是一个原子性的操作，这样某线程在执行putIfAbsent的时候其他线程也无法修改list的值。

6、总结

　　第一个例子实例封闭，将代表对象状态的变量 myset定义为final类型的，然后把使用这个变量的方法都加上锁，这样就能保证多线程程序使用这个类的时候的原子性。

　　第二个记录车辆坐标的类中，记录对象状态的变量的初始化是通过复制得到的，且得到的是一个不可修改的map，每次返回数据的时候是通过新建一个对象返回的，实现了把map变量（代表对象状态的变量）封闭在了对象中。而且在初始化和返回数据操作时加上了内置锁，实现了线程安全

　　第三个也是记录车辆坐标的，这里使用了线程安全的ConcurrentHashMap，真正代表对象状态的map变量获取数据也是从这个ConcurrentHashMap中获得，而从外界获取数据则是ConcurrentHashMap，从而实现了线程安全。

　　第四个例子中代表对象状态的两个变量使用AtomicInteger，这里只实现了数据读写的线程安全，但是在逻辑上数据的使用，也就是先检查后执行的操作是根据数据的内容进行的，而且这里的setLower和setUpper两个操作的结果还是互相影响的，所以如果想要加锁，也需要把这两个操作加在一块。

　　第五个和第六个想要解决的问题是一样的，第五个把关于list的操作加上锁实现线程安全，第六个把list封闭在对象中，实现每次进行putIfAbsent操作的时候其他线程无法改变list的内容