分段锁：零碎提供肯定数量的原始锁，依据传入对象的哈希值获取对应的锁并加锁
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;}}
}