java key锁_java细粒度锁

Java中的几种锁：synchronized，ReentrantLock，ReentrantReadWriteLock已基本可以满足编程需求，但其粒度都太大，同一时刻只有一个线程能进入同步块，这对于某些高并发的场景并不适用。

下面来提供几个更细的粒度锁：

1. 分段锁

借鉴concurrentHashMap的分段思想，先生成一定数量的锁，具体使用的时候再根据key来返回对应的lock。这是几个实现里最简单，性能最高，也是最终被采用的锁策略，代码如下：/**

* 分段锁，系统提供一定数量的原始锁，根据传入对象的哈希值获取对应的锁并加锁

* 注意：要锁的对象的哈希值如果发生改变，有可能导致锁无法成功释放!!!

*/

public class SegmentLock {

private Integer segments = 16;//默认分段数量

private final HashMap 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() % segments);

lock.lock();

}

public void unlock(T key) {

ReentrantLock lock = lockMap.get(key.hashCode() % segments);

lock.unlock();

}

}

2. 哈希锁

上述分段锁的基础上发展起来的第二种锁策略，目的是实现真正意义上的细粒度锁。每个哈希值不同的对象都能获得自己独立的锁。在测试中，在被锁住的代码执行速度飞快的情况下，效率比分段锁慢 30% 左右。如果有长耗时操作，感觉表现应该会更好。代码如下：public class HashLock {

private boolean isFair = false;

private final SegmentLock segmentLock = new SegmentLock<>();//分段锁

private final ConcurrentHashMap 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);