Java并发编程实战笔记—— 并发编程3-CSDN博客

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