いくつかのJAVA細粒度ロックの実現方式

最近、ビジネスロジックの正確性を保証するために、高い同時性のシーンがロックされる必要があり、ロック後のパフォーマンスがあまり影響を受けないことが要求されています.初歩的な考え方は,データのタイムスタンプ,idなどのキーワードによってロックを加え,異なるタイプのデータ処理の同時性を保証することである.Java自身apiが提供するロックの粒度が大きすぎて、これらのニーズを同時に満たすのは難しいので、自分でいくつかの簡単な拡張を書きました...
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()>>>1) % segments);
    lock.lock();
  }

  public void unlock(T key) {
    ReentrantLock lock = lockMap.get((key.hashCode()>>>1) % segments);
    lock.unlock();
  }
}

2.ハッシュロック
上記セグメントロックに基づいて発展した第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);
        }
      } 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();
    }
  }
}

3.弱い参照ロック
ハッシュ・ロックは、ロックの作成と破棄の同期を保証するために導入されたセグメント・ロックであり、常に欠陥を感じているため、より良いパフォーマンスとより微細なロックを求めるために3番目のロックが書かれています.このロックの考え方はjavaの弱いインデックスを借りてロックを作成し、ロックの破棄をjvmのゴミ回収に渡し、余分な消費を避けることです.
ちょっと残念だったのは、ロックの容器としてConcurrentHashMapを使用していたので、本格的な意味ではセグメントロックから抜け出すことができませんでした.このロックの性能はHashLockより10%程度速い.ロックコード:

/**
 *     ，                 
 */
public class WeakHashLock {
  private ConcurrentHashMap> lockMap = new ConcurrentHashMap<>();
  private ReferenceQueue queue = new ReferenceQueue<>();

  public ReentrantLock get(T key) {
    if (lockMap.size() > 1000) {
      clearEmptyRef();
    }
    WeakReference 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 weakLockRef = (WeakLockRef) ref;
      lockMap.remove(weakLockRef.key);
    }
  }

  private static final class WeakLockRef extends WeakReference {
    final T key;

    private WeakLockRef(K referent, ReferenceQueue super K> q, T key) {
      super(referent, q);
      this.key = key;
    }
  }
}
 

後記
最初はlocksupportとAQSを利用して細粒度ロックを実現しようとしたが、実現しているものとjava原生のロックの違いが大きくないことを発見したと書いてあったので、javaにロックを持参したパッケージに変更することを放棄し、多くの時間を浪費した.
実際にこれらの細粒度ロックを実現した後、例えばセグメント化思想によってデータを専門のスレッドに提出することで処理することができ、大量のスレッドのブロック時間を減らし、後日の探索を待つことができるという新しい考えがあった.