Java中线程间嵌套数据结构的同步

发布于 2024-10-16 07:00:35 字数 1326 浏览 2 评论 0原文

我有一个这样的缓存实现：

class X
{
  private final Map<String, ConcurrentMap<String, String>> structure = new HashMap...(); 

  public String getValue(String context, String id)
  {
     // just assume for this example that there will be always an innner map
     final ConcurrentMap<String, String> innerStructure = structure.get(context);

     String value = innerStructure.get(id);
     if(value == null)
     {
       synchronized(structure)
       {
          // can I be sure, that this inner map will represent the last updated
          // state from any thread?
          value = innerStructure.get(id);
          if(value == null)
          {
            value = getValueFromSomeSlowSource(id);
            innerStructure.put(id, value); 
          }
       }
     }       
     return value;
  }
}

这个实现是线程安全的吗？我能否确保从同步块内的任何线程获取最后更新的状态？如果我使用 java.util.concurrent.ReentrantLock 而不是同步块，这种行为是否会改变，如下所示：

...
if(lock.tryLock(3, SECONDS))
{
  try
  {
    value = innerStructure.get(id);
    if(value == null)
    {
      value = getValueFromSomeSlowSource(id);
      innerStructure.put(id, value); 
    }
  }
  finally
  {
    lock.unlock();
  }
}
...

我知道最终实例成员在线程之间同步，但是对于这些成员持有的对象来说也是如此吗？

也许这是一个愚蠢的问题，但我不知道如何测试它以确保它适用于每个操作系统和每个架构。

原文

I have a cache implementation like this:

class X
{
  private final Map<String, ConcurrentMap<String, String>> structure = new HashMap...(); 

  public String getValue(String context, String id)
  {
     // just assume for this example that there will be always an innner map
     final ConcurrentMap<String, String> innerStructure = structure.get(context);

     String value = innerStructure.get(id);
     if(value == null)
     {
       synchronized(structure)
       {
          // can I be sure, that this inner map will represent the last updated
          // state from any thread?
          value = innerStructure.get(id);
          if(value == null)
          {
            value = getValueFromSomeSlowSource(id);
            innerStructure.put(id, value); 
          }
       }
     }       
     return value;
  }
}

Is this implementation thread-safe? Can I be sure to get the last updated state from any thread inside the synchronized block? Would this behaviour change if I use a java.util.concurrent.ReentrantLock instead of a synchronized block, like this:

...
if(lock.tryLock(3, SECONDS))
{
  try
  {
    value = innerStructure.get(id);
    if(value == null)
    {
      value = getValueFromSomeSlowSource(id);
      innerStructure.put(id, value); 
    }
  }
  finally
  {
    lock.unlock();
  }
}
...

I know that final instance members are synchronized between threads, but is this also true for the objects held by these members?

Maybe this is a dumb question, but I don't know how to test it to be sure, that it works on every OS and every architecture.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

止于盛夏 2024-10-23 07:00:35

对于初学者来说，这不是一个愚蠢的问题。同步确实很难做到正确，而且我并不自称是这方面的专家。

在您的程序中，在指定的上下文中，是的，您可以假设您获得的 String 是最新版本。但是，您的代码仍然不安全，因为您正在从 synchronized 块外部的 Map 读取值。如果此读取发生在 Map 向其中插入值的同时，则不能保证您能返回一个合理的值。我知道至少在某些实现上，由于实现中的一些奇怪之处，这可能会导致无限循环。

简而言之，您不应该拥有一个由多个线程读取或写入的结构，除非您使用同步原语（如 synchronized 或锁）来保护它，或者除非该结构是专门设计用于像 ConcurrentHashMap 一样是无锁的。

在这种情况下，您确实可以使用 ReentrantLock 来保护对结构的访问并进行定时等待，但如果这样做，您必须保证对该结构的任何读取也受到相同的锁。否则，您将面临多个线程看到不一致或损坏的数据的风险。