并发编程3

Posted xxbbtt

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了并发编程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的内容

以上是关于并发编程3的主要内容,如果未能解决你的问题,请参考以下文章

golang代码片段(摘抄)

《java并发编程实战》

Java并发编程实战 04死锁了怎么办?

Java并发编程实战 04死锁了怎么办?

Java编程思想之二十 并发

golang goroutine例子[golang并发代码片段]