JAVA 如何基于String实现同步锁?转载

原创
小哥 4年前 (2022-10-18) 阅读数 1 #大杂烩

在某些情况下,我们可能希望基于字符串执行某些操作,例如:对于同一用户的并发同步操作,使用锁字符串实现更有意义。这是因为只有在同一字符串上才不允许并发操作。如果我们不分青红皂白地直接给它们添加锁,那么整体性能就会大幅下降。

因为string看起来的多样性看起来像是看起来的多样性string锁自然比像段锁这样的高级锁更有优势。

因为String 变量赋值的类型类似于类型的变量赋值如下: String a = "hello world."; 经常有一种错误的印象,即所有人都倾向于有一种错误的印象,即经常存在一种错误的形象,即String对象是不可变的。该对象只是不可变的。该对象是不可变的。对象是不可变的。

嗯,关于这个问题的辩论我们就不谈细节了,简而言之, "a" != "a" 很可能会坚持下去。很可能是真的。这是有可能的。这是有可能的。

此外,对于锁的事情,我们都知道锁是针对同一对象的,以便有意义。因此,粗略地说,我们可以使用这样的串锁:

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

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

乍一看,这看起来确实很方便和简单。但是,如前所述, "a" 很可能不等于很可能不等于很可能不等于 "a" S(这是大多数情况,仅当s(大多数时间,仅当s(这是大多数时间,仅当s(这是大多数时间,仅当String存储在常量池中时,相同的String(变量仅相等)。(变量只是相等的)。

所以,我们可以优化它,我们可以优化它,我们可以稍微优化,我们可以稍微优化它:

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...
    }
}

它看起来仍然很方便和简单,原则是把String对象添加到常量池中。但会有一个问题,如何清理这些恒定池的数据?

在任何情况下,我们都无法立足于我们自己,我们能否立足于我们自己String实现一个锁怎么样?实现一个锁怎么样?如何实现锁呢?

这绝对是可能的!直接进入代码!

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

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

/**
 * 基于string 的锁实现
 */
public final class StringBasedMutexLock {

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

/**
 * 字符锁 管理器, 把每根线放在每根线上,把每根线放在每根线上 转换为转换为 CountDownLatch
 *
 *      也就是说,只有在实际存在并发更新时才会发生锁定 同一个 String 的情况下
 *
 */
private static final ConcurrentMap lockKeyHolder = new ConcurrentHashMap<>();

/**
 * 基于lockKey 锁定、同步执行锁定和同步执行
 *
 * @param lockKey 字符锁
 */
public static void lock(String lockKey) {
    while (!tryLock(lockKey)) {
        try {
            logger.debug("[Character Lock]并发更新锁升级, {}", lockKey);
            blockOnSecondLevelLock(lockKey);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            logger.error("[字符锁定]中断异常字符锁定]中断异常:" + lockKey, e);
            break;
        }
    }
}

/**
 * 释放 lockKey 相应的锁定选项,以使其他线程可执行
 *
 * @param lockKey 使用互斥字符串使用互斥字符串使用互斥字符串
 * @return true: 释放成功, false: 释放失败,可能被其他线程错误释放
 */
public static boolean unlock(String lockKey) {
    // 先解锁,再解锁,这里会导致后续的并发执行先来,不起作用
    CountDownLatch realLock = getAndReleaseLock1(lockKey);
    releaseSecondLevelLock(realLock);
    return true;
}

/**
 * 尝试锁定指定的字符串尝试锁定指定的字符串尝试锁定指定的字符串
 *
 * @param lockKey 使用互斥字符串使用互斥字符串使用互斥字符串
 * @return true: 上锁成功, false: 上锁失败
 */
private static boolean tryLock(String lockKey) {
    // 这将导致大量的这一地区的原因 ReentrantLock 创建对象?对象是否已创建?
    // 实际上,它不会。最大数量等于外部并发的数量,只是 gc 不是很友善,会反复制造反复破坏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 获取对应的锁实例,获取对应的锁实例,获取对应的锁实例
 *
 * @param lockKey 字符串锁
 * @return 锁实例
 */
private static CountDownLatch getRealLockByKey(String lockKey) {
    return lockKeyHolder.get(lockKey);
}

}

要使用它,只需传入使用,只需传入使用它,只需传入使用它,只需传入 lockKey 即可。

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

这样做有什么好处吗?这样做有什么好处吗?这样做有什么好处吗?这有什么好处吗?

  1. 使用ConcurrentHashMap实现锁获取,性能依然不错;
  2. 每个字符串对应一个锁,该锁在使用后被删除,不会导致内存溢出问题;
  3. 它可以用作外部工具,轻松访问业务代码,而不需要像这样的外部工具 synchronized 同样,需要包装整个代码一样;

缺点?不足之处?缺乏症?不够用?

  1. 使用ConcurrentHashMap实现锁获取,性能依然不错;
  2. 每个字符串对应一个锁,该锁在使用后被删除,不会导致内存溢出问题;
  3. 它可以用作外部工具,轻松访问业务代码,而不需要像这样的外部工具 synchronized 同样,需要包装整个代码一样;
  4. 这篇文章只是想展示一下 String 锁,不适合分布式场景下的并发处理;

扩展: 如果您不使用不使用如果不使用如果您不使用 String 如何在大并发前提下,针对小概率并发场景做锁定,确保线程安全?

我们知道 CAS 效率更高,我们可以使用原子类CAS的操作。

比如,我们添加状态字段我们添加状态字段我们添加状态字段, 操作此字段以确保线程安全操作此字段以确保线程安全操作此字段以确保线程安全:

/**
 * 运行状态
 *
 *         4: 正在删除, 1: 被放入被放入队列, 0: 正常无操作正常无操作
 */
private transient volatile AtomicInteger runningStatus = new AtomicInteger(0);

// 更新时先获取此状态更新时先获取状态更新时先获取状态:
public void method5() {
    AtomicInteger runningStatus = link.getRunningStatus();
    // 在删除数据的过程中,那么在删除数据的过程中等待,在删除数据的过程中等待,在删除数据的过程中等待
    if(!runningStatus.compareAndSet(0, 1)) {
        // 1. 等待另一个线程完成删除等待另一个线程完成删除
        // 2. 删除正在更新的徽标删除正在更新的徽标删除正在更新的标志删除正在更新的标志
        // 3. 重新运行该数据放置逻辑重新运行该数据放置逻辑此时重新运行该数据放置逻辑
        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("数据正在更新数据正在更新,重新运行: " + 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(" 数据正在更新数据正在更新,不能删除,请返回 ");
        return;
    }
    try {
        // do sync things
    }
    catch (Exception e) {
        logger.error("并发更新异常并发更新异常:", e);
    }
    finally {
        runningStatus.compareAndSet(4, 0);
    }
}

实际测试归结为实际测试归结为实际测试归结为CAS 性能要好于性能要好于 synchronized 这样的锁性能更好。当然,我们在这里针对的并发数量非常少,我们只是希望在这些罕见的情况下确保线程安全。所以,这实际上是可以的。

版权声明

所有资源都来源于爬虫采集,如有侵权请联系我们,我们将立即删除