Question

我编写了一个任务监听器模型作为下面的代码，是否可以对其进行任何优化或错误修复（如果有），特别是List和Map访问？在这个模型中，创建一个Map来容纳几个包含一些用户监听器的List，大多数每个List的大小大约为1000。这里有两点： 1.为了性能，使用HashMap或ConcurrentHashMap？ 2.这是一种比复制List更好的方法，并在多线程访问时迭代复制的List吗？

public class TaskActionManager {

    private static final Map<String, List<TaskActionListener>> listenersMap = new ConcurrentHashMap<String, List<TaskActionListener>>();
    private static final ExecutorService executor = Executors
            .newCachedThreadPool();
    private static ReentrantLock lock = new ReentrantLock();

    public static final void addListener(TaskActionListener listener,
            TaskActionType type) {
        // type is an enum
        String key = type.name();

        List<TaskActionListener> list = listenersMap.get(key);
        lock.lock();
        try {
            // Mostly the list is not null
            if (list == null) {
                list = listenersMap.get(key);
                if (list == null) {
                    list = new ArrayList<TaskActionListener>();
                    listenersMap.put(key, list);
                }
            }
            list.add(listener);
        } finally {
            lock.unlock();
        }
    }

    public static final void removeListener(TaskActionListener listener,
            TaskActionType type) {
        List<TaskActionListener> list = listenersMap.get(type.name());
        if (list == null)
            return;

        lock.lock();
        try {
            list.remove(listener);
        } finally {
            lock.unlock();
        }
    }

    public static final void fireAction(final TaskAction action) {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                List<TaskActionListener> list = listenersMap.get(action
                        .getType().name());
                if (list == null)
                    return;

                // Make a copy
                List<TaskActionListener> copy = null;
                lock.lock();
                try {
                    copy = new ArrayList<TaskActionListener>(list.size());
                    Collections.copy(list, copy);
                } finally {
                    lock.unlock();
                }

                // Iterate the copy
                if (copy != null) {
                    for (TaskActionListener listener : copy) {
                        try {
                            listener.fireAction(action);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
    }
}

Answer 1

表现性能，使用HashMap或ConcurrentHashMap？

显然，ConcurrentHashMap是HashMap的并发版本。所以答案是，无疑是ConcurrentHashMap。它使用起来更简单，也更有效，因为你不需要锁定它，因为它是线程安全的。

是一种比复制List更好的方法，并在多线程访问时迭代复制的List吗？

ConcurrentHashMap是线程安全的，因此您无需进行复制即可进行迭代。如果你不介意你的列表在迭代时改变（通过另一个线程），我不明白为什么你应该在这里，那么这就是要走的路。

有关详情，请参阅：http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/ConcurrentHashMap.html

注意：

迭代器被设计为一次只能由一个线程使用。

与Hashtable类似，但与HashMap不同，此类不允许使用null 用作键或值。

在Map中同时访问List

1 个答案: