-
很多情况下应该重用现有的类, 添加自定义的功能, 此时需要在__不破坏线程安全性__的情况下添加新的操作
(1) 方法一: 直接修改原始的类
优点: 同步策略仍然处于同一个源代码文件中, 更容易理解和维护
缺点: 常常无法修改源代码
(2) 方法二: 扩展这个类
同步策略分布到了各个文件中, 并且要确定的得知基类的同步策略
示例
@ThreadSafe public class BetterVector<E> extends Vector<E> { // When extending a serializable class, you should redefine serialVersionUID static final long serialVersionUID = -3963416950630760754L; public synchronized boolean putIfAbsent(E x) { boolean absent = !super.contains(x); if (absent) { super.add(x); } return absent; } }
(3) 方法三: 客户端加锁机制
扩展类的功能, 但不是扩展类本身, 而是将扩展代码放入__辅助类__中
客户端加锁: 对于使用某个对象X的客户端代码, 使用__X本身用于保护其状态的锁__来保护这段客户代码
所以, 使用客户端加锁方式, 必须从源码中找到X使用的是哪一个锁
示例
错误示例
@NotThreadSafe class BadListHelper<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; } }
正确示例
@ThreadSafe class GoodListHelper<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; } } }
正确示例和错误示例的区别在于使用锁的不同, 深入Collections.synchronizedList的源码, 会发现它使用的锁就是Collections.synchronizedList对象本身, 所以辅助类中也要使用Collections.synchronizedList本身作为锁
和方法二一样, 客户端加锁方式也存在同步策略分布在各个类中的问题, 这样当底层源码的同步策略改变时可能会不稳。
(4) 方法四: 组合
使用Java监视器模式, 对内部的对象完全由类本身提供的锁保护, 不管底层的类是否线程安全
示例
@ThreadSafe public class ImprovedList<T> implements List<T> { private final List<T> list; public ImprovedList(List<T> list) { this.list = list; } public synchronized boolean putIfAbsent(T x) { boolean contains = list.contains(x); if (contains) { list.add(x); } return !contains; } // Plain vanilla delegation for List methods. // Mutative methods must be synchronized to ensure atomicity of putIfAbsent. public synchronized boolean addAll(Collection<? extends T> c) { return list.addAll(c); } public synchronized boolean addAll(int index, Collection<? extends T> c) { return list.addAll(index, c); } public synchronized boolean removeAll(Collection<?> c) { return list.removeAll(c); } public synchronized boolean retainAll(Collection<?> c) { return list.retainAll(c); } public synchronized void clear() { list.clear(); } public synchronized boolean add(T e) { return list.add(e); } public synchronized boolean remove(Object o) { return list.remove(o); } public int size() { return list.size(); } public boolean isEmpty() { return list.isEmpty(); } public boolean contains(Object o) { return list.contains(o); } public Iterator<T> iterator() { return list.iterator(); } public Object[] toArray() { return list.toArray(); } public <T> T[] toArray(T[] a) { return list.toArray(a); } public boolean containsAll(Collection<?> c) { return list.containsAll(c); } public boolean equals(Object o) { return list.equals(o); } public int hashCode() { return list.hashCode(); } public T get(int index) { return list.get(index); } public T set(int index, T element) { return list.set(index, element); } public void add(int index, T element) { list.add(index, element); } public T remove(int index) { return list.remove(index); } public int indexOf(Object o) { return list.indexOf(o); } public int lastIndexOf(Object o) { return list.lastIndexOf(o); } public ListIterator<T> listIterator() { return list.listIterator(); } public ListIterator<T> listIterator(int index) { return list.listIterator(index); } public List<T> subList(int fromIndex, int toIndex) { return list.subList(fromIndex, toIndex); } }
所有需要同步的方法都使用ImprovedList本身的锁, 而不必在意封装对象的同步策略
-
同步策略应该文档化
定义好
(1) 哪些变量为volatile
(2) 哪些变量用锁保护
(3) 哪些变量必须不可变或者线程封闭
(4) 哪些操作必须是原子操作
等……
chapter04_对象的组合_4_在现有的线程安全类中添加功能
最新推荐文章于 2021-07-22 00:33:36 发布