标签：因此 str 情况下 private his list 其他 需要 构造函数
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的内容
标签：因此 str 情况下 private his list 其他 需要 构造函数
原文地址：http://www.cnblogs.com/xxbbtt/p/7879543.html
