Java线程安全的DAO

Question

I have a DAOClass which is called from many Threads as below for inserting into a set of tables -

public class DAOClass
{

private HashMap<String, HelperClass> insertBuffer;


public DAOClass() 
{
    insertBuffer = new HashMap<String, HelperClass>();      
}

public int[] createSomeTable(String key, SomeTableRecord someTableRecord) 
{
        List<SomeTableRecord> someTableRecList;
        HelperClass buf = insertBuffer.get(key);
        if (buf == null)
        {
            buf = new HelperClass();
            insertBuffer.put(key, buf);
        }

        someTableRecList = buf.getSomeTableBuffer();
        someTableRecList.add(someTableRecord);

        if(someTableRecList.size() >= Global.limit())
        {
            return flushSomeTableInsertCache(key);
        }
        else
        {
            return null;
        }
}

public int[] flushSomeTableInsertCache(String key)
{
    HelperClass buf = insertBuffer.get(key);
    int[] retVal = null;
    if (buf != null && buf.getSomeTableBuffer() != null)
    {
        retVal = createSomeTableBuffered(buf.getSomeTableBuffer());
        buf.getSomeTableBuffer().clear();
    }
    return retVal;
}

}

public int[] createSomeTableBuffered(final List<SomeTableRecord> someTableRecordList) 
{
  INSERT QUERY GOES HERE from LIST..
}
}

Different Threads call createSomeTable method which adds to an ArrayList of a HelperClass. There is a HashMap but the key is overlapping ie same key is hit by multiple threads simultaneously, thus corrupting HashMap and untimely flushings ..

Helper Class follows -

class HelperClass {

private String key;
private ArrayList<SomeTableRecord> someTableBuffer;
private ArrayList<SomeTable1Record> someTable1Buffer;


HelperClass() {

    someTableBuffer = new ArrayList<SomeTableRecord>();
    someTable1Buffer = new ArrayList<SomeTable1Record>();

}

public ArrayList<SomeTableRecord> getSomeTableBuffer() {
    return someTableBuffer;
}

public ArrayList<SomeTable1Record> getSomeTable1Buffer() {
    return someTable1Buffer;
}
}

But, this is apparently not thread safe as key is not disjoint. Can you please suggest some correction in the classes so that it is thread safe.

Answer 1

请改用ConcurrentHashMap类。

Answer 2

You should rather use ArrayList<HelperClass> than HashMap. To avoid conflicts, use

public synchronized int[] createSomeTable(String key, SomeTableRecord someTableRecord) 

to protect your buffer.

UPDATE:

To protect the buffer even in Spring, add synchronized to flushSomeTableInsertCache as well:

public synchronized int[] flushSomeTableInsertCache(String key)

Actually you don't use key s just to identify the elements.

Otherwise it is not a good strategy to watch key collisions this way, because they can even happen between 2 flushes, so you should either check them in the database, or have a separate HashSet for the keys (if you are sure that you have all the keys in there).

Answer 3

insertBuffer is the only state here. Modifying its content in a multi-threaded environment might result in unexpected behavior. You can either synchronize access to it or use ConcurrentHashMap instead of HashMap .

Answer 4

I would use synchronized methods rather than ConcurrentHashMap . However, using ConcurrentHashMap might solve your thread-safe-issue as well.

Answer 5

区分用法的最简单方法是为每个线程创建一个DAOClass对象。

Answer 6

将您的实现更改为ConcurrentHashMap，这将解决您的并发问题。