分段锁：零碎提供肯定数量的原始锁，依据传入对象的哈希值获取对应的锁并加锁
public class SegmentLock<T> {
private Integer segments = 16;// 默认分段数量
private final HashMap<Integer, ReentrantLock> lockMap = new HashMap<>();
public SegmentLock() {
init(null, false);}
public SegmentLock(Integer counts, boolean fair) {
init(counts, fair);}
private void init(Integer counts, boolean fair) {
if (counts != null) {segments = counts;}
for (int i = 0; i < segments; i++) {lockMap.put(i, new ReentrantLock(fair));
}}
public void lock(T key) {
ReentrantLock lock = lockMap.get((key.hashCode()>>>1) % segments);
lock.lock();}
public void unlock(T key) {
ReentrantLock lock = lockMap.get((key.hashCode()>>>1) % segments);
lock.unlock();}
}
哈希锁：上述分段锁的根底上倒退起来的第二种锁策略，目标是实现真正意义上的细粒度锁。每个哈希值不同的对象都能取得本人独立的锁。
public class HashLock<T> {
private boolean isFair = false;
private final SegmentLock<T> segmentLock = new SegmentLock<>();// 分段锁
private final ConcurrentHashMap<T, LockInfo> lockMap = new ConcurrentHashMap<>();
public HashLock() {
}
public HashLock(boolean fair) {
isFair = fair;}
public void lock(T key) {
LockInfo lockInfo;
segmentLock.lock(key);
try {lockInfo = lockMap.get(key);
if (lockInfo == null) {lockInfo = new LockInfo(isFair);
lockMap.put(key, lockInfo);
} else {lockInfo.count.incrementAndGet();
}
} finally {segmentLock.unlock(key);
}
lockInfo.lock.lock();}
public void unlock(T key) {
LockInfo lockInfo = lockMap.get(key);
if (lockInfo.count.get() == 1) {segmentLock.lock(key);
try {if (lockInfo.count.get() == 1) {lockMap.remove(key);
}
} finally {segmentLock.unlock(key);
}
}
lockInfo.count.decrementAndGet();
lockInfo.unlock();}
private static class LockInfo {
public ReentrantLock lock;
public AtomicInteger count = new AtomicInteger(1);
private LockInfo(boolean fair) {this.lock = new ReentrantLock(fair);
}
public void lock() {this.lock.lock();
}
public void unlock() {this.lock.unlock();
}}
}
弱援用锁：哈希锁因为引入的分段锁来保障锁创立和销毁的同步，总感觉有点瑕疵，所以写了第三个锁来寻求更好的性能和更细粒度的锁。这个锁的思维是借助 java 的弱援用来创立锁，把锁的销毁交给 jvm 的垃圾回收，来防止额定的耗费。
public class WeakHashLock<T> {
private ConcurrentHashMap<T, WeakLockRef<T, ReentrantLock>> lockMap = new ConcurrentHashMap<>();
private ReferenceQueue<ReentrantLock> queue = new ReferenceQueue<>();
public ReentrantLock get(T key) {
if (lockMap.size() > 1000) {clearEmptyRef();
}
WeakReference<ReentrantLock> lockRef = lockMap.get(key);
ReentrantLock lock = (lockRef == null ? null : lockRef.get());
while (lock == null) {lockMap.putIfAbsent(key, new WeakLockRef<>(new ReentrantLock(), queue, key));
lockRef = lockMap.get(key);
lock = (lockRef == null ? null : lockRef.get());
if (lock != null) {return lock;}
clearEmptyRef();}
return lock;}
@SuppressWarnings(“unchecked”)
private void clearEmptyRef() {
Reference<? extends ReentrantLock> ref;
while ((ref = queue.poll()) != null) {WeakLockRef<T, ? extends ReentrantLock> weakLockRef = (WeakLockRef<T, ? extends ReentrantLock>) ref;
lockMap.remove(weakLockRef.key);
}}
private static final class WeakLockRef<T, K> extends WeakReference<K> {
final T key;
private WeakLockRef(K referent, ReferenceQueue<? super K> q, T key) {super(referent, q);
this.key = key;
}}
}