java - 锁定中心化交易

Question

我有以下情况:

public class LockingScenario {

    public static final ConcurrentHashMap<String, Vector<Task>> BUFFER = new ConcurrentHashMap<>();
    private static final ConcurrentHashMap<String, Object> LOCKS = new ConcurrentHashMap<>();
    private static final Object SURROGATE = new Object();

    public void bufferTransaction(Context ctx) {

        String transaction = ctx.getTransaction();

        Object obj = LOCKS.putIfAbsent(transaction, SURROGATE);
        Vector<Task> tasks;
        Iterator<String> it = LOCKS.keySet().iterator();

        while (it.hasNext()) {
            String key = it.next();
            if (key.equals(transaction)) {
                transaction = key;
            }
        }

        //minimize the case when there will be created useless Vector objects.
        if (obj == null) {
            tasks = new Vector<>();
            BUFFERS.putIfAbsent(transaction, tasks);
        }

        syncrhonized(transaction) {
            tasks = BUFFERS.get(transaction);
        }
        //... create task
        tasks.add(task);
        // ... 

    }

    public void finishTransaction(Context ctx) {
        String transaction = ctx.getTransaction();
        Vector<Task> tasks = BUFFER.get(transaction);
        // finish job here...
    }
}

我试图在这里解释一下上面的代码及其上下文:

LockingScenario 是托管 Bean 的类，它由启动不同事务的不同线程访问。每笔交易都有一个唯一的编号以及与其关联的许多要执行的任务。

我面临以下问题:我需要锁定在许多线程之间共享一些内存的部分代码，为许多事务发送许多任务，这些任务必须由一个托管 bean(该 bean 实际上可以有多个托管实例)。

问题:对于这种情况是否有更好的方法？假设我的方法是正确的(我的意思是它没有错误)。

重要提示:在上述场景中，您应该只考虑 bufferTransaction 及其上面的代码。下面的代码实际上位于不同的托管 bean 中。我把它放在那里是为了让你了解整个情况。

Answer 1

我很确定你可以简单地这样做:

class LockingScenario {
    private static final Map<String, Vector<Task>> BUFFER = new ConcurrentHashMap<>();

    public void bufferTransaction(Context ctx) {
        String transaction = ctx.getTransaction();
        Vector<Task> tasks;
        // prevent creation of two Vectors for the same transaction
        synchronized (BUFFER) {
            tasks = BUFFER.get(transaction);
            if (tasks == null) {
                tasks = new Vector<>();
                BUFFER.put(transaction, tasks);
            }
        }
        // create tasks and put into Vector
        tasks.add(createTask());
    }
}

任务列表检索/创建足够快，您可以在这段时间内阻塞整个缓冲区。

使用 Java 8，您将使用

synchronized (BUFFER) {
    tasks = BUFFER.computeIfAbsent(transaction, s -> new Vector<>());
}