Java并发编程规则：设计线程安全的类
封装设计：
尽管所有的状态都存储在公共静态变量（域）中，仍然能写出线程安全的程序，但比起那些适当封装的类来说，我们难以验证这种程序的线程安全性，也很难再修改它的同步不破坏它的线程安全性。在没有进行全局检查的情况下，封装能够保证线程的安全性。
=====设计线程安全类的过程应该包括下面3个基本要素：========
1、确定对象状态是由哪些变量组成的；
2、确定限制状态变量的不变约束；
3、制定一个管理并发访问对象状态的策略。
同步策略方式：
对状态使用同步策略，以维护其不变约束。需要明确的是同步的需求是什么，并分析其不可变约束和后验条件。
package net.jcip.examples;
import net.jcip.annotations.*;
/**
* Counter
* <p/>
* Simple thread-safe counter using the Java monitor pattern
*
* @author Brian Goetz and Tim Peierls
*/
@ThreadSafe
public final class Counter {
@GuardedBy("this") private long value = 0;
public synchronized long getValue() {
return value;
}
public synchronized long increment() {
if (value == Long.MAX_VALUE)
throw new IllegalStateException("counter overflow");
return ++value;
}
}
实例限制：
限制性使构造线程安全的类更容易。因为类的状态被限制后，分析它的线程安全性时，就不必检查完整的程序。
将数据封装在实体内部，把对数据的访问限制在对象的方法上，更易确保线程在访问数据时总能获得正确的锁。示例如下：
package net.jcip.examples;
import java.util.*;
import net.jcip.annotations.*;
/**
* PersonSet
* <p/>
* Using confinement to ensure thread safety
*
* @author Brian Goetz and Tim Peierls
*/
@ThreadSafe
public class PersonSet {
@GuardedBy("this") private final Set<Person> mySet = new HashSet<Person>();
public synchronized void addPerson(Person p) {
mySet.add(p);
}
public synchronized boolean containsPerson(Person p) {
return mySet.contains(p);
}
interface Person {
}
}
Java监视器模式：
像Vector和HashTable这样的核心库类，都是采用了Java监视器模式，其最大优势在于简单。Java监视器模式仅仅是一种习惯约定：任意锁对象只要始终如一地使用，都可以用来保护对象的状态。来看个私有锁保护状态的示例：
package net.jcip.examples;
import net.jcip.annotations.*;
/**
* PrivateLock
* <p/>
* Guarding state with a private lock
*
* @author Brian Goetz and Tim Peierls
*/
public class PrivateLock {
private final Object myLock = new Object();
@GuardedBy("myLock") Widget widget;
void someMethod() {
synchronized (myLock) {
// Access or modify the state of widget
}
}
}
package net.jcip.examples;
import java.util.*;
import net.jcip.annotations.*;
/**
* MonitorVehicleTracker
* <p/>
* Monitor-based vehicle tracker implementation
*
* @author Brian Goetz and Tim Peierls
*/
@ThreadSafe
public class MonitorVehicleTracker {
@GuardedBy("this") 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);
}
public synchronized void setLocation(String id, int x, int y) {
MutablePoint loc = locations.get(id);
if (loc == null)
throw new IllegalArgumentException("No such ID: " + id);
loc.x = x;
loc.y = y;
}
private static 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)));
return Collections.unmodifiableMap(result);
}
}
package net.jcip.examples;
import net.jcip.annotations.*;
/**
* MutablePoint
* <p/>
* Mutable Point class similar to java.awt.Point
*
* @author Brian Goetz and Tim Peierls
*/
@NotThreadSafe
public class MutablePoint {
public int x, y;
public MutablePoint() {
x = 0;
y = 0;
}
public MutablePoint(MutablePoint p) {
this.x = p.x;
this.y = p.y;
}
}
委托线程安全：
委托线程安全，就是使用现有的线程安全的类来实现线程安全，即由其代为控制线程安全。下面来看个使用委托的机动车追踪器，ConcurrentMap线程安全委托：
package net.jcip.examples;
import java.util.*;
import java.util.concurrent.*;
import java.awt.*;
import java.awt.Point;
import net.jcip.annotations.*;
/**
* DelegatingVehicleTracker
* <p/>
* Delegating thread safety to a ConcurrentHashMap
*
* @author Brian Goetz and Tim Peierls
*/
@ThreadSafe
public class DelegatingVehicleTracker {
private final ConcurrentMap<String, Point> locations;
private final Map<String, Point> unmodifiableMap;
public DelegatingVehicleTracker(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 locations.get(id);
}
public void setLocation(String id, int x, int y) {
if (locations.replace(id, new Point(x, y)) == null)
throw new IllegalArgumentException("invalid vehicle name: " + id);
}
// Alternate version of getLocations (Listing 4.8)
public Map<String, Point> getLocationsAsStatic() {
return Collections.unmodifiableMap(
new HashMap<String, Point>(locations));
}
}
package net.jcip.examples;
import net.jcip.annotations.*;
/**
* Point
* <p/>
* Immutable Point class used by DelegatingVehicleTracker
*
* @author Brian Goetz and Tim Peierls
*/
@Immutable
public class Point {
public final int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
package net.jcip.examples;
import java.awt.event.KeyListener;
import java.awt.event.MouseListener;
import java.util.*;
import java.util.concurrent.*;
/**
* VisualComponent
* <p/>
* Delegating thread safety to multiple underlying state variables
*
* @author Brian Goetz and Tim Peierls
*/
public class VisualComponent {
private final List<KeyListener> keyListeners = new CopyOnWriteArrayList<KeyListener>();
private final List<MouseListener> mouseListeners = new CopyOnWriteArrayList<MouseListener>();
public void addKeyListener(KeyListener listener) {
keyListeners.add(listener);
}
public void addMouseListener(MouseListener listener) {
mouseListeners.add(listener);
}
public void removeKeyListener(KeyListener listener) {
keyListeners.remove(listener);
}
public void removeMouseListener(MouseListener listener) {
mouseListeners.remove(listener);
}
}
安全发布状态：
底层可变的状态也可以是线程安全的类。示例：
package net.jcip.examples;
import net.jcip.annotations.*;
/**
* SafePoint
*
* @author Brian Goetz and Tim Peierls
*/
@ThreadSafe
public class SafePoint {
@GuardedBy("this") private int x, y;
private SafePoint(int[] a) {
this(a[0], a[1]);
}
public SafePoint(SafePoint p) {
this(p.get());
}
public SafePoint(int x, int y) {
this.set(x, y);
}
public synchronized int[] get() {
return new int[]{x, y};
}
public synchronized void set(int x, int y) {
this.x = x;
this.y = y;
}
}
package net.jcip.examples;
import java.util.*;
import java.util.concurrent.*;
import net.jcip.annotations.*;
/**
* PublishingVehicleTracker
* <p/>
* Vehicle tracker that safely publishes underlying state
*
* @author Brian Goetz and Tim Peierls
*/
@ThreadSafe
public class PublishingVehicleTracker {
private final Map<String, SafePoint> locations;
private final Map<String, SafePoint> unmodifiableMap;
public PublishingVehicleTracker(Map<String, SafePoint> locations) {
this.locations = new ConcurrentHashMap<String, SafePoint>(locations);
this.unmodifiableMap = Collections.unmodifiableMap(this.locations);
}
public Map<String, SafePoint> getLocations() {
return unmodifiableMap;
}
public SafePoint getLocation(String id) {
return locations.get(id);
}
public void setLocation(String id, int x, int y) {
if (!locations.containsKey(id))
throw new IllegalArgumentException("invalid vehicle name: " + id);
locations.get(id).set(x, y);
}
}
扩展已有线程安全类：
重要思想：缺少即加入。
扩展Vector为例：
package net.jcip.examples;
import java.util.*;
import net.jcip.annotations.*;
/**
* BetterVector
* <p/>
* Extending Vector to have a put-if-absent method
*
* @author Brian Goetz and Tim Peierls
*/
@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 = !contains(x);
if (absent)
add(x);
return absent;
}
}
使用客户端加锁（缺少即加入）：明确可变约束，加锁的位置很重要。
package net.jcip.examples;
import java.util.*;
import net.jcip.annotations.*;
/**
* ListHelder
* <p/>
* Examples of thread-safe and non-thread-safe implementations of
* put-if-absent helper methods for List
*
* @author Brian Goetz and Tim Peierls
*/
@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;
}
}
}
package net.jcip.examples;
import java.util.*;
import net.jcip.annotations.*;
/**
* ImprovedList
*
* Implementing put-if-absent using composition
*
* @author Brian Goetz and Tim Peierls
*/
@ThreadSafe
public class ImprovedList<T> implements List<T> {
private final List<T> list;
/**
* PRE: list argument is thread-safe.
*/
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;
}
public synchronized void clear() { list.clear(); }
// ..................
}
纸上得来终觉浅，绝知此事要躬行。
浙公网安备 33010602011771号