我最近一直在阅读 Java Concurrency in Practice - 很棒的书。如果你认为你知道并发是如何工作的，但大多数时候你面临真正的问题，感觉 SWAG 是你能做的最多的事情，那么这本书肯定会对这个话题有所启发。当您尝试在线程之间共享数据时，实际上有多少事情会出错，这有点可怕。我想这可能让我对线程安全有点疯狂。现在我担心的是，如果同步过多，我可能会遇到一些 active 问题。这里有一段代码来说明:

   private final Hashtable<String, AtomicInteger> userSessions =
new Hashtable<String, AtomicInteger>();

   public void registerUser(String userLogin) {
       synchronized(userSessions) {
           AtomicInteger sessionCount = userSessions.get(userLogin);
           if (sessionCount != null) {
               sessionCount.incrementAndGet();
           } else {
               userSessions.put(userLogin, new AtomicInteger(1));
           }
       }
   }

   public void unregisterUser(String userLogin) {
       synchronized(userSessions) {
           AtomicInteger sessionCount = userSessions.get(userLogin);
           if (sessionCount != null) {
               sessionCount.decrementAndGet();
           }
       }
   }

   public boolean isUserRegistered(String userLogin) {
       synchronized(userSessions) {
           AtomicInteger sessionCount = userSessions.get(userLogin);
           if (sessionCount == null) {
               return false;
           }
           return sessionCount.intValue() > 0;
       }
   }

我试着把它弄好:在静态部分构建同步集合并存储在静态最终引用中以安全发布，锁定集合(而不是 this - 这样我就不会阻塞代码所在的整个类)并为原语使用原子包装类。书中提到过度这样做也可能会导致问题，但似乎我需要更多时间来完全理解它。 您将如何使此代码成为线程安全的并确保它不会受到 active 和性能问题的影响？

编辑:把它变成实例方法和变量，最初一切都被声明为静态 - 糟糕的，糟糕的设计。还将 userSessions 设为私有(private)(以前不知何故我将其设为公开)。

最佳答案

使用 ConcurrentHashMap 以便您可以使用 putIfAbsent。您无需AtomicInteger 代码即可同步。

   public final ConcurrentMap<String, AtomicInteger> userSessions =
       new ConcurrentHashMap<String, AtomicInteger>();

   public void registerUser(String userLogin) {
       AtomicInteger newCount = new AtomicInteger(1);
       AtomicInteger oldCount = userSessions.putIfAbsent(userLogin, newCount);
       if (oldCount != null) {
           oldCount.incrementAndGet();
       }
   }

   public void unregisterUser(String userLogin) {
       AtomicInteger sessionCount = userSessions.get(userLogin);
       if (sessionCount != null) {
           sessionCount.decrementAndGet();
       }
   }

   public boolean isUserRegistered(String userLogin) {
       AtomicInteger sessionCount = userSessions.get(userLogin);
       return sessionCount != null && sessionCount.intValue() > 0;
   }

注意，这会泄露...

尝试非泄漏版本:

   public final ConcurrentMap<String, Integer> userSessions =
       new ConcurrentHashMap<String, Integer>();

   public void registerUser(String userLogin) {
       for (;;) {
           Integer old = userSessions.get(userLogin);
           if (userSessions.replace(userLogin, old, old==null ? 1 : (old+1)) {
                break;
           }
       }
   }
   public void unregisterUser(String userLogin) {
       for (;;) {
           Integer old = userSessions.get(userLogin);
           if (old == null) {
               // Wasn't registered - nothing to do.
               break;
           } else if (old == 1) {
               // Last one - attempt removal.
               if (userSessions.remove(userLogin, old)) {
                   break;
               }
           } else {
               // Many - attempt decrement.
               if (userSessions.replace(userLogin, old, old-1) {
                   break;
               } 
           }
       }
   }
   public boolean isUserRegistered(String userLogin) {serLogin);
       return userSessions.containsKey(userLogin);
   }

关于java - 多少线程安全是太多了？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/1819345/