迭代/循环时添加HashMap和ArrayList

Question

我有一个游戏，每隔X秒它就会把内存中改变的值写回我的数据库。当编辑这些值保存的数据时，它们存储在容器（HashMaps和ArrayList）中。

为了简单起见，假设我只有一个容器可以写入数据库：

html" target="_blank">public static HashMap<String, String> dbEntitiesDeletesBacklog = new HashMap<String, String>();

我的DB写入循环：

Timer dbUpdateJob = new Timer();
dbUpdateJob.schedule(new TimerTask() {
    public void run() {
        long startTime = System.nanoTime();
        boolean updateEntitiesTableSuccess = UpdateEntitiesTable();
        if (!updateEntitiesTableSuccess){
            try {
                conn.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
                logger.fatal(e.getMessage());
                System.exit(1);
            }
        } else { //everything saved to DB - commit time
            try {
                conn.commit();
            } catch (SQLException e) {
                e.printStackTrace();
                logger.fatal(e.getMessage());
                System.exit(1);
            }
        }
        logger.debug("Time to save to DB: " + (System.nanoTime() - startTime) / 1000000 + " milliseconds");
    }
}, 0, 10000); //TODO:: figure out the perfect saving delay

我的更新方法：

private boolean UpdateEntitiesTable() {
    Iterator<Entry<String, String>> it = dbEntitiesDeletesBacklog.entrySet().iterator();
    while (it.hasNext()) {
        Entry<String, String> pairs = it.next();
        String tmpEntityId = pairs.getKey();

        int deletedSuccess = UPDATE("DELETE" + 
                " FROM " + DB_NAME + ".entities" + 
                " WHERE entity_id=(?)", new String[]{tmpEntityId});
        if (deletedSuccess != 1) {
            logger.error("Entity " + tmpEntityId + " was unable to be deleted.");
            return false;
        }
        it.remove();
        dbEntitiesDeletesBacklog.remove(tmpEntityId);
    }

我是否需要在为dbEntitiesDeletesBacklog HashMap和本摘录中未包含的其他容器“保存到DB”时创建某种锁定机制？我想我需要这样做，因为它会创建迭代器，然后循环。如果在创建迭代器之后，在循环遍历条目之前添加了什么呢。很抱歉，这更多的是一个过程问题，而不是一个代码帮助问题（因为我包含了这么多示例代码），但我想确保很容易理解我试图做什么和问什么。

同样的问题也适用于我使用的其他容器：

public static ArrayList<String> dbCharacterDeletesBacklog =  new ArrayList<String>();

private boolean DeleteCharactersFromDB() {
    for (String deleteWho : dbCharacterDeletesBacklog){
        int deleteSuccess = MyDBSyncher.UPDATE("DELETE FROM " + DB_NAME + ".characters" +
                " WHERE name=(?)", 
                new String[]{deleteWho});

        if (deleteSuccess != 1) {
            logger.error("Character(deleteSuccess): " + deleteSuccess);
            return false;
        }
    }
    dbCharacterDeletesBacklog.clear();
    return true;
}

一如既往，非常感谢您在这方面的帮助。非常感谢！！

Answer 1

以下是我将使用的示例。我在这里发帖，希望它能帮助其他人解决类似的问题。

public class MyDBSyncher {

    public static boolean running = false;
    public static HashMap<String, String> dbEntitiesInsertsBacklog_A = new HashMap<String, String>();
    public static HashMap<String, String> dbEntitiesInsertsBacklog_B = new HashMap<String, String>();

    public MyDBSyncher(){
        Timer dbUpdateJob = new Timer();
        dbUpdateJob.schedule(new TimerTask() {
            public void run() {
                running = true;
                boolean updateEntitiesTableSuccess = UpdateEntitiesTable();
                running = false;
            }
        }, 0, 10000); //TODO:: figure out the perfect saving delay
    }

    public HashMap getInsertableEntitiesHashMap(){
        if (running){
            return dbEntitiesInsertsBacklog_B;
        } else {
            return dbEntitiesInsertsBacklog_A;
        }
    }

    private boolean UpdateEntitiesTable() {
        Iterator<Entry<String, String>> it2 = getInsertableEntitiesHashMap().entrySet().iterator();
        while (it2.hasNext()) {
            Entry<String, String> pairs = it2.next();
            String tmpEntityId = pairs.getKey();

            //some DB updates here

            it2.remove();
            getInsertableEntitiesHashMap().remove(tmpEntityId);
        }
        return true;
    }
}

Answer 2

如果同时访问地图，至少需要一个同步地图（通过Collections.synchronizedMap），否则可能会遇到不确定性行为。

除此之外，正如您所建议的，您还需要在迭代期间锁定地图。来自集合的javadoc。synchronizedMap（）建议如下：

当用户迭代其任何集合视图时，必须手动同步返回的映射：

Map m = Collections.synchronizedMap(new HashMap());
      ...
Set s = m.keySet();  // Needn't be in synchronized block
      ...
synchronized(m) {  // Synchronizing on m, not s!
    Iterator i = s.iterator(); // Must be in synchronized block
    while (i.hasNext())
        foo(i.next());
}

不遵循此建议可能会导致不确定性行为。

或者，使用ConexttHashMap而不是常规的HashMap，以避免在迭代期间需要同步。对于游戏来说，这可能是一个更好的选择，因为你可以避免长时间锁定你的收藏。

可能更好的方法是，考虑旋转新集合，这样每次更新数据库时，都可以获取集合，并将其替换为一个新的空集合，所有新更新都将写入其中，从而避免在数据库写入时锁定集合。在这种情况下，集合将由某个容器管理，以允许此抓取和替换是线程安全的。