Java 中 String 对象的同步

Question

我有一个网络应用程序，正在对其进行一些负载/性能测试，特别是在一个功能上，我们预计数百个用户将访问同一页面，并在此页面上每 10 秒点击刷新一次。 我们发现可以利用此功能进行改进的一个方面是，将来自 Web 服务的响应缓存一段时间，因为数据不会发生变化。

实现这个基本的缓存后，在一些进一步的测试中我发现我没有考虑并发线程如何同时访问缓存。 我发现在大约 100 毫秒的时间内，大约有 50 个线程试图从缓存中获取对象，发现它已经过期，然后访问 Web 服务来获取数据，然后将对象放回缓存中。

原始代码如下所示：

private SomeData[] getSomeDataByEmail(WebServiceInterface service, String email) {

  final String key = "Data-" + email;
  SomeData[] data = (SomeData[]) StaticCache.get(key);

  if (data == null) {
      data = service.getSomeDataForEmail(email);

      StaticCache.set(key, data, CACHE_TIME);
  }
  else {
      logger.debug("getSomeDataForEmail: using cached object");
  }

  return data;
}

因此，为了确保当 key 处的对象过期时只有一个线程正在调用 Web 服务，我认为我需要同步 Cache get/set 操作，并且看起来使用缓存键将是对象同步的一个很好的候选者（这样，调用此方法来获取电子邮件 [电子邮件受保护] 不会被对 [电子邮件受保护]）。

我更新了该方法，如下所示：

private SomeData[] getSomeDataByEmail(WebServiceInterface service, String email) {

  
  SomeData[] data = null;
  final String key = "Data-" + email;
  
  synchronized(key) {      
    data =(SomeData[]) StaticCache.get(key);

    if (data == null) {
        data = service.getSomeDataForEmail(email);
        StaticCache.set(key, data, CACHE_TIME);
    }
    else {
      logger.debug("getSomeDataForEmail: using cached object");
    }
  }

  return data;
}

我还添加了诸如“同步块之前”、“同步块内部”、“即将离开同步块”和“同步块之后”之类的日志记录行，这样我就可以确定我是否有效地同步获取/设置操作。

然而这似乎并没有奏效。 我的测试日志的输出如下：

(log output is 'threadname' 'logger name' 'message')  
http-80-Processor253 jsp.view-page - getSomeDataForEmail: about to enter synchronization block  
http-80-Processor253 jsp.view-page - getSomeDataForEmail: inside synchronization block  
http-80-Processor253 cache.StaticCache - get: object at key [[email protected]] has expired  
http-80-Processor253 cache.StaticCache - get: key [[email protected]] returning value [null]  
http-80-Processor263 jsp.view-page - getSomeDataForEmail: about to enter synchronization block  
http-80-Processor263 jsp.view-page - getSomeDataForEmail: inside synchronization block  
http-80-Processor263 cache.StaticCache - get: object at key [[email protected]] has expired  
http-80-Processor263 cache.StaticCache - get: key [[email protected]] returning value [null]  
http-80-Processor131 jsp.view-page - getSomeDataForEmail: about to enter synchronization block  
http-80-Processor131 jsp.view-page - getSomeDataForEmail: inside synchronization block  
http-80-Processor131 cache.StaticCache - get: object at key [[email protected]] has expired  
http-80-Processor131 cache.StaticCache - get: key [[email protected]] returning value [null]  
http-80-Processor104 jsp.view-page - getSomeDataForEmail: inside synchronization block  
http-80-Processor104 cache.StaticCache - get: object at key [[email protected]] has expired  
http-80-Processor104 cache.StaticCache - get: key [[email protected]] returning value [null]  
http-80-Processor252 jsp.view-page - getSomeDataForEmail: about to enter synchronization block  
http-80-Processor283 jsp.view-page - getSomeDataForEmail: about to enter synchronization block  
http-80-Processor2 jsp.view-page - getSomeDataForEmail: about to enter synchronization block  
http-80-Processor2 jsp.view-page - getSomeDataForEmail: inside synchronization block  

我想一次只看到一个线程进入/退出围绕 get/set 操作的同步块。

同步 String 对象是否存在问题？ 我认为缓存键将是一个不错的选择，因为它对于操作来说是唯一的，即使在方法中声明了最终字符串键，我认为每个线程都会获得一个引用到同一个对象，因此会在这个单个对象上进行同步。

我在这里做错了什么？

更新：进一步查看日志后，似乎具有相同同步逻辑的方法，其中密钥始终相同，例如

final String key = "blah";
...
synchronized(key) { ...

不会表现出相同的并发问题 - 一次只有一个线程进入区块。

更新2：感谢大家的帮助！ 我接受了关于 intern() 字符串的第一个答案，它解决了我最初的问题 - 多个线程在我认为不应该进入的地方进入同步块，因为 key具有相同的值。

正如其他人指出的那样，使用 intern() 达到这样的目的并同步这些字符串确实是一个坏主意 - 当针对 web 应用程序运行 JMeter 测试以模拟预期负载时，我发现已用堆大小在不到 20 分钟内增长到近 1GB。

目前，我正在使用同步整个方法的简单解决方案 - 但我真的喜欢 martinprobst 和 MBCook 提供的代码示例，但因为我有大约 7 个类似的 getData() 方法（因为它需要来自 Web 服务的大约 7 个不同的数据），我不想向每个方法添加有关获取和释放锁的几乎重复的逻辑。 但这对于未来的使用来说绝对是非常非常有价值的信息。 我认为这些最终是关于如何最好地使这样的线程安全的操作的正确答案，如果可以的话，我会给这些答案更多的选票！

Answer 1

使用合适的缓存框架，例如 ehcache。

实现良好的缓存并不像某些人认为的那么容易。

关于 String.intern() 是内存泄漏源的评论实际上是不正确的。
Interned Strings 被垃圾收集，只是可能需要更长的时间，因为在某些 JVM (SUN) 上，它们存储在 Perm 空间中，该空间仅被完整 GC 触及。

Answer 2

您可以使用 1.5 并发实用程序来提供一个缓存，该缓存旨在允许多个并发访问和单点添加（即只有一个线程执行昂贵的对象“创建”）：

 private ConcurrentMap<String, Future<SomeData[]> cache;
 private SomeData[] getSomeDataByEmail(final WebServiceInterface service, final String email) throws Exception {

  final String key = "Data-" + email;
  Callable<SomeData[]> call = new Callable<SomeData[]>() {
      public SomeData[] call() {
          return service.getSomeDataForEmail(email);
      }
  }
  FutureTask<SomeData[]> ft; ;
  Future<SomeData[]> f = cache.putIfAbsent(key, ft= new FutureTask<SomeData[]>(call)); //atomic
  if (f == null) { //this means that the cache had no mapping for the key
      f = ft;
      ft.run();
  }
  return f.get(); //wait on the result being available if it is being calculated in another thread
}

显然，这不会像您那样处理异常d 希望这样做，并且缓存没有内置逐出功能。不过，也许您可​​以使用它作为更改 StaticCache 类的基础。

Answer 3

调用：

   final String key = "Data-" + email;

每次调用方法时都会创建一个新对象。 因为该对象是您用来锁定的对象，并且每次调用此方法都会创建一个新对象，所以您并没有真正根据键同步对映射的访问。

这进一步解释了您的编辑。 当你有一个静态字符串时，它就会起作用。

使用 intern() 可以解决这个问题，因为它从 String 类保留的内部池中返回字符串，这确保了如果两个字符串相等，则将使用池中的一个。 请参阅

http://java .sun.com/j2se/1.4.2/docs/api/java/lang/String.html#intern()

Answer 4

在我看来，这个问题有点太宽泛了，因此它引发了同样广泛的答案。 因此，我将尝试回答问题 我已被重定向自，不幸的是，该地址已因重复而被关闭。

public class ValueLock<T> {

    private Lock lock = new ReentrantLock();
    private Map<T, Condition> conditions  = new HashMap<T, Condition>();

    public void lock(T t){
        lock.lock();
        try {
            while (conditions.containsKey(t)){
                conditions.get(t).awaitUninterruptibly();
            }
            conditions.put(t, lock.newCondition());
        } finally {
            lock.unlock();
        }
    }

    public void unlock(T t){
        lock.lock();
        try {
            Condition condition = conditions.get(t);
            if (condition == null)
                throw new IllegalStateException();// possibly an attempt to release what wasn't acquired
            conditions.remove(t);
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

在执行（外部）lock 操作时，将获取（内部）锁以在短时间内获得对映射的独占访问权限，如果相应的对象已在映射中，则当前线程将等待,
否则它将把新的Condition放入映射中，释放（内部）锁并继续，
并且（外部）锁被认为已获得。
（外部）unlock 操作首先获取（内部）锁，将在 Condition 上发出信号，然后从映射中删除对象。

该类不使用 Map 的并发版本，因为对它的每次访问都受到单个（内部）锁的保护。

请注意，此类的 lock() 方法的语义与 ReentrantLock.lock() 不同，即重复的 lock() 调用如果没有配对的 unlock() 将无限期地挂起当前线程。

OP 描述了可能适用于这种情况的用法示例

    ValueLock<String> lock = new ValueLock<String>();
    // ... share the lock   
    String email = "...";
    try {
        lock.lock(email);
        //... 
    } finally {
        lock.unlock(email);
    }

Answer 5

您的主要问题不仅仅是可能存在具有相同值的多个 String 实例。 主要问题是您只需要一个监视器来同步访问 StaticCache 对象。 否则，多个线程可能最终会同时修改 StaticCache（尽管在不同的键下），这很可能不支持并发修改。

Answer 6

这是相当晚的，但这里有很多不正确的代码。

在此示例中：

private SomeData[] getSomeDataByEmail(WebServiceInterface service, String email) {


  SomeData[] data = null;
  final String key = "Data-" + email;

  synchronized(key) {      
    data =(SomeData[]) StaticCache.get(key);

    if (data == null) {
        data = service.getSomeDataForEmail(email);
        StaticCache.set(key, data, CACHE_TIME);
    }
    else {
      logger.debug("getSomeDataForEmail: using cached object");
    }
  }

  return data;
}

同步范围不正确。 对于支持 get/put API 的静态缓存，至少应该在 get 和 getIfAbsentPut 类型操作之间进行同步，以便安全地访问缓存。 同步的范围将是缓存本身。

如果必须对数据元素本身进行更新，则会增加一个额外的同步层，该层应该位于各个数据元素上。

SynchronizedMap 可以用来代替显式同步，但仍然必须小心。 如果使用了错误的 API（get 和 put 而不是 putIfAbsent），则尽管使用了同步映射，操作也不会进行必要的同步。 请注意使用 putIfAbsent 带来的复杂性：即使在不需要的情况下也必须计算 put 值（因为 put 在检查缓存内容之前无法知道是否需要 put 值），或者需要仔细计算使用委托（例如，使用 Future，它有效，但有点不匹配；见下文），其中根据需要获取看跌期权价值。

使用 Future 是可能的，但看起来相当尴尬，而且可能有点过度设计。 Future API 是异步操作的核心，特别是对于可能不会立即完成的操作。 涉及 Future 很可能会增加一层线程创建——更可能是不必要的复杂化。

使用 Future 进行此类操作的主要问题是 Future 本质上与多线程相关。 当不需要新线程时使用 Future 意味着忽略 Future 的许多机制，使其成为用于此用途的过于繁重的 API。

Answer 7

2019 年最新更新，

如果您正在寻找在 JAVA 中实现同步的新方法，这个答案适合您。

我发现了 Anatoliy Korovin 的这篇精彩博客，这将帮助您深入了解同步。

如何通过对象的值同步块在Java中。

这帮助我希望新开发者也会发现它很有用。

Answer 8

为什么不直接渲染一个静态 html 页面，为用户提供服务并每 x 分钟重新生成一次？

Answer 9

如果不需要的话，我还建议完全摆脱字符串连接。

final String key = "Data-" + email;

缓存中是否还有其他使用电子邮件地址的事物/对象类型，您需要在密钥开头添加额外的“Data-”？

如果没有，我就这样做

final String key = email;

，你也可以避免所有额外的字符串创建。

Answer 10

如果其他人有类似的问题，据我所知，以下代码可以工作：

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;

public class KeySynchronizer<T> {

    private Map<T, CounterLock> locks = new ConcurrentHashMap<>();

    public <U> U synchronize(T key, Supplier<U> supplier) {
        CounterLock lock = locks.compute(key, (k, v) -> 
                v == null ? new CounterLock() : v.increment());
        synchronized (lock) {
            try {
                return supplier.get();
            } finally {
                if (lock.decrement() == 0) {
                    // Only removes if key still points to the same value,
                    // to avoid issue described below.
                    locks.remove(key, lock);
                }
            }
        }
    }

    private static final class CounterLock {

        private AtomicInteger remaining = new AtomicInteger(1);

        private CounterLock increment() {
            // Returning a new CounterLock object if remaining = 0 to ensure that
            // the lock is not removed in step 5 of the following execution sequence:
            // 1) Thread 1 obtains a new CounterLock object from locks.compute (after evaluating "v == null" to true)
            // 2) Thread 2 evaluates "v == null" to false in locks.compute
            // 3) Thread 1 calls lock.decrement() which sets remaining = 0
            // 4) Thread 2 calls v.increment() in locks.compute
            // 5) Thread 1 calls locks.remove(key, lock)
            return remaining.getAndIncrement() == 0 ? new CounterLock() : this;
        }

        private int decrement() {
            return remaining.decrementAndGet();
        }
    }
}

在OP的情况下，它将像这样使用：

private KeySynchronizer<String> keySynchronizer = new KeySynchronizer<>();

private SomeData[] getSomeDataByEmail(WebServiceInterface service, String email) {
    String key = "Data-" + email;
    return keySynchronizer.synchronize(key, () -> {
        SomeData[] existing = (SomeData[]) StaticCache.get(key);
        if (existing == null) {
            SomeData[] data = service.getSomeDataForEmail(email);
            StaticCache.set(key, data, CACHE_TIME);
            return data;
        }
        logger.debug("getSomeDataForEmail: using cached object");
        return existing;
    });
}

如果同步代码不应返回任何内容，则可以编写同步方法像这样：

public void synchronize(T key, Runnable runnable) {
    CounterLock lock = locks.compute(key, (k, v) -> 
            v == null ? new CounterLock() : v.increment());
    synchronized (lock) {
        try {
            runnable.run();
        } finally {
            if (lock.decrement() == 0) {
                // Only removes if key still points to the same value,
                // to avoid issue described below.
                locks.remove(key, lock);
            }
        }
    }
}

Answer 11

在字符串对象上同步的其他方式：

String cacheKey = ...;

    Object obj = cache.get(cacheKey)

    if(obj==null){
    synchronized (Integer.valueOf(Math.abs(cacheKey.hashCode()) % 127)){
          obj = cache.get(cacheKey)
         if(obj==null){
             //some cal obtain obj value,and put into cache
        }
    }
}

Answer 12

如果以正确的方式完成（没有其他库或使用 intern()），这会增加代码的复杂性。 是否值得使用以下方法取决于应用程序。 它基于 vadzim 的进一步回答。 我刚刚添加了一个 keyLockCounter Map 来解决他提到的可能发生的竞争条件。 因此，在 keyLockCounter Map 中，我们总结了特定键的等待线程。

    private final Map<String, Object> keyLocks = new ConcurrentHashMap<>();
    private final Map<String, AtomicInteger> keyLockCounter = new ConcurrentHashMap<>();

    private SomeData[] getSomeDataByEmail(WebServiceInterface service, String email) {
        final String key = "Data-" + email;
        synchronized (keyLocks.compute(key, (k, value) -> {
            if (value == null) {
                keyLockCounter.put(key, new AtomicInteger(1));
                return new Object();
            } else {
                var counterValue = keyLockCounter.computeIfAbsent(key, k2 -> new AtomicInteger(0));
                if (counterValue.incrementAndGet() == 1) {
                    return new Object();
                }
                return value;
            }
        })) {
            try {
                // Do anything which needs to be synchronized
            } finally {
                var lockValue = keyLocks.get(key);
                var counterValue = keyLockCounter.get(key);
                if (counterValue.decrementAndGet() == 0) {
                    if(keyLocks.remove(filename, lockValue)) {
                        keyLockCounter.remove(filename, counterValue);
                    }
                }
            }
        }
    }

Answer 13

您应该非常小心地使用具有同步功能的短期对象。 每个 Java 对象都有一个附加的监视器，默认情况下该监视器是缩小的； 但是，如果两个线程争用获取监视器，则监视器会膨胀。 如果该对象寿命很长，那么这不是问题。 然而，如果对象的寿命很短，那么清理这个膨胀的监视器可能会严重影响 GC 时间（因此延迟更高，吞吐量更低）。 而且甚至很难发现 GC 时间，因为它并不总是列出。

如果您确实想要同步，可以使用 java.util.concurrent.Lock。 或者使用手动制作的条带锁，并使用字符串的哈希值作为该条带锁的索引。 保留这个条纹锁，这样就不会出现 GC 问题。

所以像这样：

static final Object[] locks = newLockArray();

Object lock = locks[hashToIndex(key.hashcode(),locks.length];
synchronized(lock){
       ....
}

int hashToIndex(int hash, int length) {
    if (hash == Integer.MIN_VALUE return 0;
    return abs(hash) % length;
}

Answer 14

在你的情况下，你可以使用这样的东西（这不会泄漏任何内存）：

private Synchronizer<String> synchronizer = new Synchronizer();

private SomeData[] getSomeDataByEmail(WebServiceInterface service, String email) {
    String key = "Data-" + email;

    return synchronizer.synchronizeOn(key, () -> {

        SomeData[] data = (SomeData[]) StaticCache.get(key);
        if (data == null) {
            data = service.getSomeDataForEmail(email);
            StaticCache.set(key, data, CACHE_TIME);
        } else {
          logger.debug("getSomeDataForEmail: using cached object");
        }
        return data;

    });
}

要使用它，你只需添加一个依赖项：

compile 'com.github.matejtymes:javafixes:1.3.0'

Answer 15

我添加了一个小锁类，可以锁定/同步任何键，包括字符串。

请参阅 Java 8、Java 6 的实现和一个小测试。

Java 8：

public class DynamicKeyLock<T> implements Lock
{
    private final static ConcurrentHashMap<Object, LockAndCounter> locksMap = new ConcurrentHashMap<>();

    private final T key;

    public DynamicKeyLock(T lockKey)
    {
        this.key = lockKey;
    }

    private static class LockAndCounter
    {
        private final Lock lock = new ReentrantLock();
        private final AtomicInteger counter = new AtomicInteger(0);
    }

    private LockAndCounter getLock()
    {
        return locksMap.compute(key, (key, lockAndCounterInner) ->
        {
            if (lockAndCounterInner == null) {
                lockAndCounterInner = new LockAndCounter();
            }
            lockAndCounterInner.counter.incrementAndGet();
            return lockAndCounterInner;
        });
    }

    private void cleanupLock(LockAndCounter lockAndCounterOuter)
    {
        if (lockAndCounterOuter.counter.decrementAndGet() == 0)
        {
            locksMap.compute(key, (key, lockAndCounterInner) ->
            {
                if (lockAndCounterInner == null || lockAndCounterInner.counter.get() == 0) {
                    return null;
                }
                return lockAndCounterInner;
            });
        }
    }

    @Override
    public void lock()
    {
        LockAndCounter lockAndCounter = getLock();

        lockAndCounter.lock.lock();
    }

    @Override
    public void unlock()
    {
        LockAndCounter lockAndCounter = locksMap.get(key);
        lockAndCounter.lock.unlock();

        cleanupLock(lockAndCounter);
    }


    @Override
    public void lockInterruptibly() throws InterruptedException
    {
        LockAndCounter lockAndCounter = getLock();

        try
        {
            lockAndCounter.lock.lockInterruptibly();
        }
        catch (InterruptedException e)
        {
            cleanupLock(lockAndCounter);
            throw e;
        }
    }

    @Override
    public boolean tryLock()
    {
        LockAndCounter lockAndCounter = getLock();

        boolean acquired = lockAndCounter.lock.tryLock();

        if (!acquired)
        {
            cleanupLock(lockAndCounter);
        }

        return acquired;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException
    {
        LockAndCounter lockAndCounter = getLock();

        boolean acquired;
        try
        {
            acquired = lockAndCounter.lock.tryLock(time, unit);
        }
        catch (InterruptedException e)
        {
            cleanupLock(lockAndCounter);
            throw e;
        }

        if (!acquired)
        {
            cleanupLock(lockAndCounter);
        }

        return acquired;
    }

    @Override
    public Condition newCondition()
    {
        LockAndCounter lockAndCounter = locksMap.get(key);

        return lockAndCounter.lock.newCondition();
    }
}

Java 6：

公共类 DynamicKeyLock 实现 Lock
{
私有最终静态ConcurrentHashMap locksMap = new ConcurrentHashMap();
私有最终 T 密钥；

    public DynamicKeyLock(T lockKey) {
        this.key = lockKey;
    }

    private static class LockAndCounter {
        private final Lock lock = new ReentrantLock();
        private final AtomicInteger counter = new AtomicInteger(0);
    }

    private LockAndCounter getLock()
    {
        while (true) // Try to init lock
        {
            LockAndCounter lockAndCounter = locksMap.get(key);

            if (lockAndCounter == null)
            {
                LockAndCounter newLock = new LockAndCounter();
                lockAndCounter = locksMap.putIfAbsent(key, newLock);

                if (lockAndCounter == null)
                {
                    lockAndCounter = newLock;
                }
            }

            lockAndCounter.counter.incrementAndGet();

            synchronized (lockAndCounter)
            {
                LockAndCounter lastLockAndCounter = locksMap.get(key);
                if (lockAndCounter == lastLockAndCounter)
                {
                    return lockAndCounter;
                }
                // else some other thread beat us to it, thus try again.
            }
        }
    }

    private void cleanupLock(LockAndCounter lockAndCounter)
    {
        if (lockAndCounter.counter.decrementAndGet() == 0)
        {
            synchronized (lockAndCounter)
            {
                if (lockAndCounter.counter.get() == 0)
                {
                    locksMap.remove(key);
                }
            }
        }
    }

    @Override
    public void lock()
    {
        LockAndCounter lockAndCounter = getLock();

        lockAndCounter.lock.lock();
    }

    @Override
    public void unlock()
    {
        LockAndCounter lockAndCounter = locksMap.get(key);
        lockAndCounter.lock.unlock();

        cleanupLock(lockAndCounter);
    }


    @Override
    public void lockInterruptibly() throws InterruptedException
    {
        LockAndCounter lockAndCounter = getLock();

        try
        {
            lockAndCounter.lock.lockInterruptibly();
        }
        catch (InterruptedException e)
        {
            cleanupLock(lockAndCounter);
            throw e;
        }
    }

    @Override
    public boolean tryLock()
    {
        LockAndCounter lockAndCounter = getLock();

        boolean acquired = lockAndCounter.lock.tryLock();

        if (!acquired)
        {
            cleanupLock(lockAndCounter);
        }

        return acquired;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException
    {
        LockAndCounter lockAndCounter = getLock();

        boolean acquired;
        try
        {
            acquired = lockAndCounter.lock.tryLock(time, unit);
        }
        catch (InterruptedException e)
        {
            cleanupLock(lockAndCounter);
            throw e;
        }

        if (!acquired)
        {
            cleanupLock(lockAndCounter);
        }

        return acquired;
    }

    @Override
    public Condition newCondition()
    {
        LockAndCounter lockAndCounter = locksMap.get(key);

        return lockAndCounter.lock.newCondition();
    }
}

测试：

public class DynamicKeyLockTest
{
    @Test
    public void testDifferentKeysDontLock() throws InterruptedException
    {
        DynamicKeyLock<Object> lock = new DynamicKeyLock<>(new Object());
        lock.lock();
        AtomicBoolean anotherThreadWasExecuted = new AtomicBoolean(false);
        try
        {
            new Thread(() ->
            {
                DynamicKeyLock<Object> anotherLock = new DynamicKeyLock<>(new Object());
                anotherLock.lock();
                try
                {
                    anotherThreadWasExecuted.set(true);
                }
                finally
                {
                    anotherLock.unlock();
                }
            }).start();
            Thread.sleep(100);
        }
        finally
        {
            Assert.assertTrue(anotherThreadWasExecuted.get());
            lock.unlock();
        }
    }

    @Test
    public void testSameKeysLock() throws InterruptedException
    {
        Object key = new Object();
        DynamicKeyLock<Object> lock = new DynamicKeyLock<>(key);
        lock.lock();
        AtomicBoolean anotherThreadWasExecuted = new AtomicBoolean(false);
        try
        {
            new Thread(() ->
            {
                DynamicKeyLock<Object> anotherLock = new DynamicKeyLock<>(key);
                anotherLock.lock();
                try
                {
                    anotherThreadWasExecuted.set(true);
                }
                finally
                {
                    anotherLock.unlock();
                }
            }).start();
            Thread.sleep(100);
        }
        finally
        {
            Assert.assertFalse(anotherThreadWasExecuted.get());
            lock.unlock();
        }
    }
}

Answer 16

如果您可以合理保证字符串值在系统中是唯一的，则可以安全地使用 String.intern 进行同步。 UUIDS 是解决这个问题的好方法。 您可以通过缓存、映射将 UUID 与实际的字符串键关联起来，甚至可以将 UUID 作为字段存储在实体对象上。

    @Service   
    public class MySyncService{

      public Map<String, String> lockMap=new HashMap<String, String>();

      public void syncMethod(String email) {

        String lock = lockMap.get(email);
        if(lock==null) {
            lock = UUID.randomUUID().toString();
            lockMap.put(email, lock);
        }   

        synchronized(lock.intern()) {
                //do your sync code here
        }
    }

Answer 17

在我没有完全投入大脑的情况下，从快速扫描你所说的内容来看，你似乎需要 intern() 你的字符串：

final String firstkey = "Data-" + email;
final String key = firstkey.intern();

具有相同值的两个字符串不一定是同一个对象。

请注意，这可能会引入新的争论点，因为在虚拟机深处，intern() 可能必须获取锁。 我不知道现代虚拟机在这一领域是什么样子，但人们希望它们能够得到极大的优化。

我假设您知道 StaticCache 仍然需要线程安全。 但是，与调用 getSomeDataForEmail 时锁定缓存而不是仅锁定密钥相比，那里的争用应该很小。

对问题更新的回应：

我认为这是因为字符串文字总是产生相同的对象。 Dave Costa 在评论中指出，它甚至比这更好：文字总是产生规范的表示。 因此，程序中任何位置具有相同值的所有字符串文字都会产生相同的对象。

编辑

其他人指出同步实习生字符串实际上是一个非常糟糕的主意 - 部分是因为允许创建实习生字符串导致它们永久存在，部分是因为如果程序中任何位置的多于一位代码都在实习生字符串上同步，这些代码之间存在依赖关系，并且防止死锁或其他错误可能是不可能的。

当我输入时，其他答案中正在开发通过为每个密钥字符串存储一个锁定对象来避免这种情况的策略。

这里有一个替代方案 - 它仍然使用单个锁，但我们知道无论如何我们都需要其中一个用于缓存，并且您谈论的是 50 个线程，而不是 5000 个，因此这可能不是致命的。 我还假设这里的性能瓶颈是 DoSlowThing() 中的缓慢阻塞 I/O，因此，不进行序列化将大大受益。 如果这不是瓶颈，那么：

• 如果 CPU 繁忙，那么这种方法可能不够，您需要另一种方法。
• 如果 CPU 不忙，并且对服务器的访问不是瓶颈，那么这种方法就太过分了，您不妨忘记此锁定和每键锁定，在整个操作周围放置一个大的同步（StaticCache），然后执行这是简单的方法。

显然，这种方法需要在使用前进行可扩展性浸泡测试——我不做任何保证。

此代码不要求 StaticCache 是同步的或线程安全的。 如果任何其他代码（例如旧数据的计划清理）曾经触及缓存，则需要重新审视这一点。

IN_PROGRESS 是一个虚拟值 - 不完全干净，但代码很简单，并且可以节省两个哈希表。 它不处理 InterruptedException，因为我不知道您的应用程序在这种情况下想要做什么。 另外，如果 DoSlowThing() 对于给定的键始终失败，则此代码并不完全优雅，因为每个线程都会重试它。 由于我不知道失败标准是什么，也不知道它们是暂时的还是永久的，所以我也不处理这个问题，我只是确保线程不会永远阻塞。 在实践中，您可能希望将一个数据值放入缓存中，该数据值指示“不可用”，可能有原因，以及重试的超时时间。

// do not attempt double-check locking here. I mean it.
synchronized(StaticObject) {
    data = StaticCache.get(key);
    while (data == IN_PROGRESS) {
        // another thread is getting the data
        StaticObject.wait();
        data = StaticCache.get(key);
    }
    if (data == null) {
        // we must get the data
        StaticCache.put(key, IN_PROGRESS, TIME_MAX_VALUE);
    }
}
if (data == null) {
    // we must get the data
    try {
        data = server.DoSlowThing(key);
    } finally {
        synchronized(StaticObject) {
            // WARNING: failure here is fatal, and must be allowed to terminate
            // the app or else waiters will be left forever. Choose a suitable
            // collection type in which replacing the value for a key is guaranteed.
            StaticCache.put(key, data, CURRENT_TIME);
            StaticObject.notifyAll();
        }
    }
}

每次将任何内容添加到缓存时，所有线程都会唤醒并检查缓存（无论它们后面的键是什么），因此可以使用争议较少的算法获得更好的性能。 然而，大部分工作将在大量空闲 CPU 时间阻塞 I/O 期间进行，因此这可能不是问题。

如果您为缓存及其关联的锁、它返回的数据、IN_PROGRESS 虚拟对象以及要执行的慢速操作定义了合适的抽象，则此代码可以通用用于多个缓存。 将整个事情滚动到缓存上的方法中可能不是一个坏主意。

Answer 18

其他人建议将琴弦保留下来，这会起作用。

问题是 Java 必须保留内部字符串。 有人告诉我，即使您没有持有引用，它也会这样做，因为下次有人使用该字符串时该值需要相同。 这意味着实习所有字符串可能会开始耗尽内存，这对于您所描述的负载来说可能是一个大问题。

我已经看到了两种解决方案：

您可以在另一个对象上同步，

而不是电子邮件，创建一个保存电子邮件的对象（例如用户对象），该对象将电子邮件的值保存为变量。 如果您已经有另一个代表该人的对象（假设您已经根据他们的电子邮件从数据库中提取了某些内容），您可以使用它。 通过实现 equals 方法和 hashcode 方法，您可以确保当您执行静态 cache.contains() 来查明数据是否已在缓存中时，Java 将对象视为相同的对象（您必须在缓存上同步） ）。

实际上，您可以保留第二个 Map 来锁定对象。 像这样的事情：

Map<String, Object> emailLocks = new HashMap<String, Object>();

Object lock = null;

synchronized (emailLocks) {
    lock = emailLocks.get(emailAddress);

    if (lock == null) {
        lock = new Object();
        emailLocks.put(emailAddress, lock);
    }
}

synchronized (lock) {
    // See if this email is in the cache
    // If so, serve that
    // If not, generate the data

    // Since each of this person's threads synchronizes on this, they won't run
    // over eachother. Since this lock is only for this person, it won't effect
    // other people. The other synchronized block (on emailLocks) is small enough
    // it shouldn't cause a performance problem.
}

这将阻止对同一电子邮件地址进行 15 次提取。 您需要一些东西来防止在 emailLocks 映射中出现太多条目。 使用来自 Apache Commons 的 LRUMap 将做吧。

这需要一些调整，但它可能会解决您的问题。

使用不同的密钥

如果您愿意忍受可能的错误（我不知道这有多重要），您可以使用字符串的哈希码作为密钥。 int 不需要被实习。

摘要

希望这对您有所帮助。 穿线很有趣，不是吗？ 您还可以使用会话设置一个值，表示“我已经在寻找这个”，并检查第二个（第三个、第 N 个）线程是否需要尝试创建或只是等待结果显示在缓存中。 我想我有三个建议。

Answer 19

字符串不不适合同步。 如果必须在字符串 ID 上进行同步，可以通过使用该字符串创建互斥锁来完成（请参阅“在 ID 上同步"）。 该算法的成本是否值得取决于调用您的服务是否涉及任何重要的 I/O。

另外：

• 我希望 StaticCache.get() 和 set() 方法是线程安全的。
• String.intern()这是有代价的（根据虚拟机实现的不同而不同），应该谨慎使用。

Answer 20

这是一个安全的简短 Java 8 解决方案，它使用专用锁对象的映射来进行同步：

private static final Map<String, Object> keyLocks = new ConcurrentHashMap<>();

private SomeData[] getSomeDataByEmail(WebServiceInterface service, String email) {
    final String key = "Data-" + email;
    synchronized (keyLocks.computeIfAbsent(key, k -> new Object())) {
        SomeData[] data = StaticCache.get(key);
        if (data == null) {
            data = service.getSomeDataForEmail(email);
            StaticCache.set(key, data);
        }
    }
    return data;
}

它有一个缺点，即键和锁对象将永远保留在映射中。

这可以这样解决：

private SomeData[] getSomeDataByEmail(WebServiceInterface service, String email) {
    final String key = "Data-" + email;
    synchronized (keyLocks.computeIfAbsent(key, k -> new Object())) {
        try {
            SomeData[] data = StaticCache.get(key);
            if (data == null) {
                data = service.getSomeDataForEmail(email);
                StaticCache.set(key, data);
            }
        } finally {
            keyLocks.remove(key); // vulnerable to race-conditions
        }
    }
    return data;
}

但是流行的密钥将不断地重新插入映射中，并重新分配锁定对象。

更新：当两个线程同时进入同一键但具有不同锁的同步部分时，这会留下竞争条件的可能性。

因此，使用过期的 Guava Cache 可能会更安全、更高效：

private static final LoadingCache<String, Object> keyLocks = CacheBuilder.newBuilder()
        .expireAfterAccess(10, TimeUnit.MINUTES) // max lock time ever expected
        .build(CacheLoader.from(Object::new));

private SomeData[] getSomeDataByEmail(WebServiceInterface service, String email) {
    final String key = "Data-" + email;
    synchronized (keyLocks.getUnchecked(key)) {
        SomeData[] data = StaticCache.get(key);
        if (data == null) {
            data = service.getSomeDataForEmail(email);
            StaticCache.set(key, data);
        }
    }
    return data;
}

请注意，这里是假设的StaticCache 是线程安全的，不会受到不同键的并发读写的影响。

Answer 21

在实习字符串上同步可能根本不是一个好主意 - 通过实习它，字符串会变成一个全局对象，如果您在应用程序的不同部分同步相同的实习字符串，您可能会变得非常奇怪基本上无法调试的同步问题，例如死锁。 这看起来似乎不太可能，但当它发生时，你就真的完蛋了。 作为一般规则，仅在您绝对确定模块外部没有代码可能锁定它的本地对象上进行同步。

在您的情况下，您可以使用同步哈希表来存储键的锁定对象。

例如：

Object data = StaticCache.get(key, ...);
if (data == null) {
  Object lock = lockTable.get(key);
  if (lock == null) {
    // we're the only one looking for this
    lock = new Object();
    synchronized(lock) {
      lockTable.put(key, lock);
      // get stuff
      lockTable.remove(key);
    }
  } else {
    synchronized(lock) {
      // just to wait for the updater
    }
    data = StaticCache.get(key);
  }
} else {
  // use from cache
}

这段代码有一个竞争条件，两个线程可能会先后将一个对象放入锁表中。 不过，这应该不是问题，因为这样您就只剩下一个线程调用 Web 服务并更新缓存，这应该不是问题。

如果在一段时间后使缓存失效，则应在从缓存中检索数据后再次检查数据是否为 ​​null，在 lock != null 的情况下。

或者，更简单的是，您可以使整个缓存查找方法（“getSomeDataByEmail”）同步。 这意味着所有线程在访问缓存时都必须同步，这可能会带来性能问题。 但与往常一样，首先尝试这个简单的解决方案，看看这是否真的是一个问题！ 在许多情况下不应该如此，因为您可能花费比同步更多的时间来处理结果。