我有以下类(class)。我使用 ConcurrentHashMap。我有很多线程写入 map 和一个定时器，每 5 分钟将数据保存在 map 中。 当我在 map 中写入条目时，我设法通过使用 putIfAbsent() 来实现线程安全。但是，当我从中读取然后通过 clear() 方法删除所有条目时，我不希望在读取映射内容然后删除它们的过程中有其他线程写入映射。显然，即使使用同步(锁){}，我的代码也不是线程安全的，b/c 在 saveEntries() 中拥有锁的线程不一定是在 log() 方法中写入我的映射的线程!除非我用同一个锁对象将整个代码锁定在 log() 中!

我想知道是否有任何其他方法可以实现线程安全而无需通过外部锁强制同步？非常感谢任何帮助。

public class Logging {

private static Logging instance;    
private static final String vendor1 = "vendor1";
private static final String vendor2 = "vendor2";    
private static long delay = 5 * 60 * 1000;

private ConcurrentMap<String, Event> vendor1Calls = new ConcurrentHashMap<String, Event>();
private ConcurrentMap<String, Event> vendor2Calls = new ConcurrentHashMap<String, Event>();

private Timer timer;    
private final Object lock = new Object();

private Logging(){
    timer = new Timer();                
    timer.schedule(new TimerTask() {
        public void run() {
            try {
                saveEntries();
            } catch (Throwable t) {
                timer.cancel();
                timer.purge();
            }
        }       
    }, 0, delay);
}

public static synchronized Logging getInstance(){     
    if (instance == null){
        instance = new Logging();
    }
    return instance;
 }

public void log(){      
    ConcurrentMap<String, Event> map;
    String key = "";        

    if (vendor1.equalsIgnoreCase(engine)){
        map = vendor1Calls;
    }else if(vendor2.equalsIgnoreCase(engine)){  
        map = vendor2Calls;
    }else{
        return;
    }       


    key = service + "." + method;
// It would be the code if I use a regular HashMap instead of ConcurrentHashMap
    /*Event event = map.get(key);       

    // Map does not contain this service.method, create an Event for the first     time.
    if(event == null){
        event = new Event();            
        map.put(key, event);

        // Map already contains this key, just adjust the numbers.
    }else{
        // Modify the object fields
    }*/
    //}

    // Make it thread-safe using CHM
    Event newEvent = new Event();
    Event existingEvent= map.putIfAbsent(key, newEvent); 

    if(existingEvent!=null && existingEvent!=newEvent){
        // Modify the object fields
}       

private void saveEntries(){

    Map<String, List<Event>> engineCalls = null;
    try {           

        engineCalls = new HashMap<String, List<Event>>();
        List<Event> events = null;

// How can I achieve therad safety here w/o applying any lock?
        //synchronized(lock){
            if(!vendor1Calls.isEmpty()){
                events = new ArrayList<Event>();
                events.addAll(vendor1Calls.values());
                engineCalls.put(vendor1, events);
                vendor1Calls.clear();
            }
            if(!vendor2Calls.isEmpty()){
                events = new ArrayList<Event>();
                events.addAll(vendor2Calls.values());
                engineCalls.put(vendor2, events);
                vendor2Calls.clear();
            }
        //}

// logICalls() saves the events in the DB.          
        DBHandle.logCalls(engineCalls);
    } catch (Throwable t) {         
    } finally {
        if(engineCalls!=null){
            engineCalls.clear();
        }                       
    }   
}       

最佳答案

However, when I read from it and then remove all entries by clear() method, I want no other thread writes to map while I’m in the process of reading the map contents and then removing them.

我想你想说的是你并不真正关心严格锁定 map 。相反，您只真正关心 vender1Calls.values() 和 vendor1Calls.clear() 之间的任何日志条目的丢失，对吗？

既然如此，我可以想象你可以替换

events.addAll(vendor1Calls.values());
vendor1Calls.clear();

在 saveEntries 中使用这个:

for (Iterator<Event> iter = vendor1Calls.values().iterator(); iter.hasNext(); ) {
    Event e = iter.next();
    events.add(e);
    iter.remove();
}

那样的话，您只会删除已经添加到事件列表中的事件。您仍然可以在 saveEntries() 仍在执行时写入 vendor1Calls 映射，但迭代器会跳过添加的值。

关于java - ConcurrentHashMap 的线程安全，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12115727/