避免多线程统计数据错误

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.commons.io.IOUtils;
import org.apache.log4j.Logger; 16 
public class CountSendSignalingRows {

    final private static Logger logger = Logger.getLogger(CountSendSignalingRows.class);

    static String appHome = projectConfiguration.getInstance().getString(projectConfiguration.KEY_APP_HOME_DIR);
    static String recvFilePathName = appHome + File.separator + "cfg" + File.separator + "receiveSignallingNum.txt";
    static String sendFilePathName = appHome + File.separator + "cfg" + File.separator + "forwardSignallingNum.txt";
    ConcurrentHashMap<String, AtomicInteger> countRecvSignalingNumMap = new ConcurrentHashMap<String, AtomicInteger>();
    ConcurrentHashMap<String, AtomicInteger> countSendSignalingNumMap = new ConcurrentHashMap<String, AtomicInteger>();
    String recvFileName = "";
    String sendFileName = "";

    private static class LazyHolder {
        private static final CountSendSignalingRows INSTANCE = new CountSendSignalingRows();
    }

    public static final CountSendSignalingRows getInstance() {
        return LazyHolder.INSTANCE;
    }

    private Thread t = null;

    private CountSendSignalingRows() {
        t = new Thread(new Runnable() {

            @Override
            public void run() {
                while (true) {
                    try {
                        // write recv map
                        writeFile(recvFilePathName, countRecvSignalingNumMap);
                        // write send map
                        writeFile(sendFilePathName, countSendSignalingNumMap);
                        Thread.sleep(30000);
                    } catch (Exception e) {
                        
                    }
                }
            }
        });
        
        t.start();
        
    }

    public void countRecvSignalingRows(String eventName) {

        countRecvSignalingRows(eventName, countRecvSignalingNumMap);

    }

    public void countSendSignalingRows(String eventName) {

        countRecvSignalingRows(eventName, countSendSignalingNumMap);

    }

    private void countRecvSignalingRows(String eventName,
            ConcurrentHashMap<String, AtomicInteger> countRecvSignalingNumMap) {
        AtomicInteger zeroAi = new AtomicInteger(0);
        AtomicInteger ai = countRecvSignalingNumMap.putIfAbsent(eventName, zeroAi);
        if (ai == null) {
            ai = zeroAi;
        }
        ai.incrementAndGet();
    }

    private void writeFile(String pathname, ConcurrentHashMap<String, AtomicInteger> countSignalingNumMap) {
        FileWriter fw = null;
        FileWriter fileWriter = null;
        File file = new File(pathname);
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            if (countSignalingNumMap == null || countSignalingNumMap.isEmpty()) {
                fileWriter = new FileWriter(file);
                fileWriter.write("");
                fileWriter.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            IOUtils.closeQuietly(fileWriter);
        }

        try {

            String line = System.getProperty("line.separator");
            StringBuffer str = new StringBuffer();
            fw = new FileWriter(pathname);
            Iterator<Entry<String, AtomicInteger>> iterator = countSignalingNumMap.entrySet().iterator();
            while (iterator.hasNext()) {
                Entry<String, AtomicInteger> entry = iterator.next();
                str.append(entry.getKey() + " : " + entry.getValue()).append(line);
            }
            fw.write(str.toString());
            fw.flush();
            logger.debug("The statistics are written successfully");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            IOUtils.closeQuietly(fw);
        }

    }
}