public void method1() {
  String str1 = "a";
  synchronized (str1) {
   // do sync a things...
  }
 }
  
 public void method2() {
  String str2 = "a";
  synchronized (str2) {
   // do sync b things...
  }
 }

public void method3() {
  String str1 = "a";
  synchronized (str1.intern()) {
   // do sync a things...
  }
 }

 public void method4() {
  String str2 = "a";
  synchronized (str2.intern()) {
   // do sync b things...
  }
 }

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CountDownLatch;

/**
 * 基于string 的鎖實現(xiàn)
 */
public final class StringBasedMutexLock {

 private static final Logger logger = LoggerFactory.getLogger(StringBasedMutexLock.class);

 /**
  * 字符鎖 管理器, 將每個字符串 轉(zhuǎn)換為一個 CountDownLatch
  *
  *  即鎖只會發(fā)生在真正有并發(fā)更新 同一個 String 的情況下
  *
  */
 private static final ConcurrentMap<String, CountDownLatch> lockKeyHolder = new ConcurrentHashMap<>();

 /**
  * 基于lockKey 上鎖，同步執(zhí)行
  *
  * @param lockKey 字符鎖
  */
 public static void lock(String lockKey) {
  while (!tryLock(lockKey)) {
   try {
    logger.debug("【字符鎖】并發(fā)更新鎖升級, {}", lockKey);
    blockOnSecondLevelLock(lockKey);
   } catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    logger.error("【字符鎖】中斷異常:" + lockKey, e);
    break;
   }
  }
 }

 /**
  * 釋放 lockKey 對應(yīng)的鎖選項，使其他線程可執(zhí)行
  *
  * @param lockKey 要使用互斥的字符串
  * @return true: 釋放成功, false: 釋放失敗，可能被其他線程誤釋放
  */
 public static boolean unlock(String lockKey) {
  // 先刪除鎖，再釋放鎖，此處會導(dǎo)致后續(xù)進(jìn)來的并發(fā)優(yōu)先執(zhí)行，無影響
  CountDownLatch realLock = getAndReleaseLock1(lockKey);
  releaseSecondLevelLock(realLock);
  return true;
 }

 /**
  * 嘗試給指定字符串上鎖
  *
  * @param lockKey 要使用互斥的字符串
  * @return true: 上鎖成功, false: 上鎖失敗
  */
 private static boolean tryLock(String lockKey) {
  // 此處會導(dǎo)致大量 ReentrantLock 對象創(chuàng)建嗎？
  // 其實不會的，這個數(shù)量最大等于外部并發(fā)數(shù)，只是對 gc 不太友好，會反復(fù)創(chuàng)建反復(fù)銷毀y
  return lockKeyHolder.putIfAbsent(lockKey, new CountDownLatch(1)) == null;
 }

 /**
  * 釋放1級鎖（刪除） 并返回重量級鎖
  *
  * @param lockKey 字符鎖
  * @return 真正的鎖
  */
 private static CountDownLatch getAndReleaseLock1(String lockKey) {
  return lockKeyHolder.remove(lockKey);
 }

 /**
  * 二級鎖鎖定（鎖升級）
  *
  * @param lockKey 鎖字符串
  * @throws InterruptedException 中斷時拋出異常
  */
 private static void blockOnSecondLevelLock(String lockKey) throws InterruptedException {
  CountDownLatch realLock = getRealLockByKey(lockKey);
  // 為 null 說明此時鎖已被刪除， next race
  if(realLock != null) {
   realLock.await();
  }
 }

 /**
  * 二級鎖解鎖（如有必要）
  *
  * @param realLock 鎖實例
  */
 private static void releaseSecondLevelLock(CountDownLatch realLock) {
  realLock.countDown();
 }

 /**
  * 通過key 獲取對應(yīng)的鎖實例
  *
  * @param lockKey 字符串鎖
  * @return 鎖實例
  */
 private static CountDownLatch getRealLockByKey(String lockKey) {
  return lockKeyHolder.get(lockKey);
 }

}

// 加鎖
StringBasedMutexLock.lock(linkKey);
// 解鎖
StringBasedMutexLock.unlock(linkKey);

/**
  * 運行狀態(tài)
  *
  *   4: 正在刪除, 1: 正在放入隊列中, 0: 正常無運行
  */
 private transient volatile AtomicInteger runningStatus = new AtomicInteger(0);
 
 
 // 更新時先獲取該狀態(tài):
 public void method5() {
  AtomicInteger runningStatus = link.getRunningStatus();
  // 正在刪除數(shù)據(jù)過程中，則等待
  if(!runningStatus.compareAndSet(0, 1)) {
   // 1. 等待另外線程刪除完成
   // 2. 刪除正在更新標(biāo)識
   // 3. 重新運行本次數(shù)據(jù)放入邏輯
   long lockStartTime = System.currentTimeMillis();
   long maxLockTime = 10 * 1000;
   while (!runningStatus.compareAndSet(0, 1)) {
    if(System.currentTimeMillis() - lockStartTime > maxLockTime) {
     break;
    }
   }
   runningStatus.compareAndSet(1, 0);
   throw new RuntimeException("數(shù)據(jù)正在更新,重新運行: " + link.getLinkKey() + link);
  }
  try {
   // do sync things
  }
  finally {
   runningStatus.compareAndSet(1, 0);
  }
 }
 
 public void method6() {
  AtomicInteger runningStatus = link.getRunningStatus();
  if (!runningStatus.compareAndSet(0, 4)) {
   logger.error(" 數(shù)據(jù)正在更新中，不得刪除，返回 ");
   return;
  }
  try {
   // do sync things
  }
  catch (Exception e) {
   logger.error("并發(fā)更新異常:", e);
  }
  finally {
   runningStatus.compareAndSet(4, 0);
  }
 }