Javaのきめの細かいロック

Java のいくつかのロック: synchronized、ReentrantLock、ReentrantReadWriteLock は基本的にプログラミングのニーズを満たすことができますが、その粒度が大きすぎるため、同時に 1 つのスレッドのみが同期ブロックに入ることができ、これは特定の同時実行性の高いシナリオには適していません。

以下は、さらにいくつかのきめ細かいロックを提供します:

1. セグメント化されたロック

concurrentHashMap のセグメント化のアイデアから学び、最初に特定の数のロックを生成し、使用時にキーに基づいて対応するロックを返します。 。これは、いくつかの実装の中で最も単純で最もパフォーマンスの高いロック戦略であり、最終的に採用されたロック戦略でもあります。上記のセグメント化されたロックの目的は、本当の意味でのきめ細かいロックを実現することです。異なるハッシュ値を持つ各オブジェクトは、独自の独立したロックを取得できます。テストでは、ロックされたコードが非常に高速に実行された場合、効率はセグメント化されたロックよりも約 30% 遅くなりました。長期運用があればもっとパフォーマンスが良くなるような気がします。コードは次のとおりです:

/**
 * 分段锁，系统提供一定数量的原始锁，根据传入对象的哈希值获取对应的锁并加锁
 * 注意：要锁的对象的哈希值如果发生改变，有可能导致锁无法成功释放!!!
 */
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() % segments);
        lock.lock();
    }
 
    public void unlock(T key) {
        ReentrantLock lock = lockMap.get(key.hashCode() % segments);
        lock.unlock();
    }
}

3. 弱い参照ロック

ハッシュ ロックは、ロックの作成と破棄の同期を確保するために導入されているため、常に少し欠陥があるように感じられるため、シークする 3 番目のロックを作成しました。パフォーマンスが向上し、よりきめ細かいロックが可能になります。このロックの考え方は、Java の弱い参照を使用してロックを作成し、ロックの破棄を JVM のガベージ コレクションに渡して追加の消費を避けることです。

ConcurrentHashMap がロック コンテナとして使用されているため、セグメンテーション ロックを実際に取り除くことができないのは残念です。このロックのパフォーマンスは、HashLock よりも約 10% 高速です。ロックコード:

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();
        }
    }
}

4. KEY(主キー)によるミューテックスロック

KeyLockは、異なるキー操作が行われる限り、処理対象のデータのKEY(主キー)をロックすることができます。処理が並列化され、スレッドの並列性が大幅に向上します

KeyLock には次の特徴があります: 1. きめ細かい、高い並列性

2. リエントラント

3. 公平なロック

4. ロックのオーバーヘッドReentrantLock は、処理に時間がかかり、キー範囲が広いシナリオに適しています。スレッドは 100 のアカウントにランダム転送を行い、合計 10,000 回):

タイプ: NonLockRunner (ロックなし)
消費時間: 2482ms
初期合計量: 1000000

終了合計量: 998906 (アトミック性は保証できません)

タイプ: SynchronizedR unner (同期ロックの追加) 消費時間: 20872ms

初期合計量: 1000000

終了合計量: 1000000

タイプ: ReentrantLockRunner (+ ReentrantLock ロック)

時間: 21588ms

初期合計量: 10 0 0000

解約総額: 1000000

タイプ: KeyLockRunner (+ KeyLock ロック)
時間: 2831ms
初期合計量: 1000000
終了合計量: 1000000