Java で粒度の細かいロックを実装する 3 つの方法の詳細なサンプル コード

最近、仕事で、ビジネス ロジックの正確性を保証するためにロックが必要な同時実行性の高いシナリオに遭遇しました。ロック後にパフォーマンスに大きな影響を与えないようにする必要があります。最初のアイデアは、データのタイムスタンプ、ID、その他のキーワードをロックして、さまざまな種類のデータ処理の同時実行性を確保することです。 Java 自体によって提供されるロックの粒度api は大きすぎるため、これらのニーズを同時に満たすのは難しいため、いくつかの簡単な拡張機能を自分で作成しました...

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. 弱い

リファレンス

ロック

ハッシュロックより優れたパフォーマンスとよりきめ細かいロックを見つけることができます。このロックの考え方は、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();
        }
    }
}

追記

最初は、locksupport と AQS を使用してきめ細かいロックを実装しようとしましたが、実装されている内容は Java のネイティブ ロックとあまり変わらないことがわかり、諦めました。 Java 独自のロックに切り替えると、多くの時間が無駄になります。

実際、これらのきめ細かいロックを実装した後、セグメンテーション思考による処理のためにデータを専用のスレッドに送信することで、多数のスレッドのブロック時間を短縮し、データをそのまま残すことができるという新しいアイデアが生まれました。未来の探求...

以上がJava で粒度の細かいロックを実装する 3 つの方法の詳細なサンプル コードの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。