java - 如何在保持线程安全的同时降低锁定粒度？

Question

我有一个简单的、托管的堆栈组，需要以线程安全的方式访问。我的第一个实现工作正常，但使用同步方法进行所有访问，即。锁定处于最粗略的级别。我想让锁定尽可能细化，但我不确定最好的方法。

这是我的堆栈管理器类的基础知识(为简洁起见，省略了一些细节):

public class StackManager {
    private final Map<String, Deque<String>> myStacks;
    public StackManager() {
        myStacks = new ConcurrentHashMap<String, Deque<String>>();
    }
    public synchronized void addStack(String name) {
        if (myStacks.containsKey(name)) {
            throw new IllegalArgumentException();
        }
        myStacks.put(name, new ConcurrentLinkedDeque<String>());
    }
    public synchronized void removeStack(String name) {
        if (!myStacks.containsKey(name)) {
            throw new IllegalArgumentException();
        }
        myStacks.remove(name);
    }
    public synchronized void push(String stack, String payload) {
        if (!myStacks.containsKey(stack)) {
            throw new IllegalArgumentException();
        }
        myStacks.get(stack).push(payload);
    }
    public synchronized String pop(String stack) {
        if (!myStacks.containsKey(stack)) {
            throw new IllegalArgumentException();
        }
        return myStacks.get(stack).pop();
    }
}

堆栈级方法(addStack()、removeStack())并不经常使用。不过我想知道是否可以降低他们的锁定级别。例如，如果这些方法不同步并在 myStacks 上建立了锁定，这会减少争用吗？例如，

    public void addStack(String name) {
        synchronized(myStacks) {
            if (myStacks.containsKey(name)) {
                throw new IllegalArgumentException();
            }
            myStacks.put(name, new ConcurrentLinkedDeque<String>());
        }
    }

我认为每个堆栈方法(push()、pop())是可以获得最大 yield 的地方。如果可以的话，我想实现每堆栈锁定。也就是说，仅锁定正在操作的堆栈管理器内的单个堆栈。但是我看不出有什么好方法来做到这一点。有什么建议吗？

既然我们在这里，是否有必要使用Map和Deque的并发实现？

Answer 1

这两种数据结构都是线程安全的。因此，每个隔离操作都是线程安全的。

问题是当多个操作之间存在依赖关系时执行多个操作。

在您的情况下，检查是否存在必须与实际操作是原子的，以避免竞争条件。要添加新堆栈，可以使用 putIfAbsent 方法，该方法是原子的且不同步。

要删除堆栈，您不需要检查是否存在。如果想知道是否存在，只需返回remove方法的返回值即可。如果为 null，则不存在。

要执行压入和弹出操作，您只需先获取堆栈并分配给局部变量即可。如果它为空，则它不存在。如果它不为空，则可以安全地推送或弹出。

为了保证线程安全，属性 myStacks 必须是 Final 或 volatile。

现在您不需要任何同步。我会毫无异常(exception)地选择一个解决方案。只是添加一个新的堆栈似乎更有必要。如果它可以发生在正确的程序中，那么它应该是一个受检查的异常。当它被认为是一个错误时，运行时异常更合适。

哦，三重检查并测试它，因为并发编程很棘手。