JAVA多线程统计日志计数时的线程安全及效率问题

最近工作上遇到一个需求：需要根据nginx日志去统计每个域名的qps（Query Per Second，每秒查询率）数据。

解决了日志读取等问题之后，为了写一个尽可能高效的统计模块，我决定用多线程去计数，然后将统计结果保存在Map中。用多线程去计数的需求还是比较常见的。

HashMap 线程不安全，操作时只能加synchronized，结果还是单线程的计数，效率太低。ConcurrentHashMap是线程安全的，就用它了。

先看第一版代码：

    // 先定义一个全局的Map
    private Map<String, Integer> counter = new ConcurrentHashMap<>();

    // 统计方法
    private static final String separator = "|-|";
    public void countLog(NginxLog nginxLog) {
        String key = nginxLog.getHost() + separator + nginxLog.getDate();
        // 先取一下之前的值，然后再加一插入进去
        Integer oldValue = counter.putIfAbsent(key, 1);
        if (oldValue != null) {
            counter.put(key, oldValue.intValue() + 1);
        }
    }

这段统计代码显然是不行的，ConcurrentHashMap虽然是线程安全类，并且也能保证所提供的方法是线程安全的，但是这并不代表使用它你的程序就是线程安全的。

在这段代码中counter.putIfAbsent()操作是原子性操作，counter.put()也是原子操作。但两者组合起来这就产生问题了。

我们举个例子：比如说现在有两个线程先后运行到counter.putIfAbsent()方法，然后两个线程都取到了同样的oldValue值，假设此值为10，然后两个线程都将执行counter.put()方法，此时两个线程都是在执行counter.put(key, 11)。这显然是不合理的，计数次数理应为12的。

为了解决这个问题，我想到了两种思路：

1、给countLog方法加上synchronized同步，如此使用ConcurrentHashMap就没有多大必要了，改成HashMap好了，这就是最开始的思路，代码如下：

    private Map<String, Integer> counter = new HashMap<>();

    public synchronized void countLog(NginxLog nginxLog) {
        String key = nginxLog.getHost() + separator + nginxLog.getDate();
        // 先取一下之前的值，然后再加一插入进去
        Integer oldValue = counter.putIfAbsent(key, 1);
        if (oldValue != null) {
            counter.put(key, oldValue.intValue() + 1);
        }
    }

执行测试运行结果为：

2017-11-28 14:43:17,292  INFO NginxLogCountTest - count: 100000, costTime: 23 ms

因为加了同步锁，相当于计数都是单线程在进行的，因此统计结果也是正确的，耗时23ms

2、第二种思路，使用AtomicInteger类计数。ConcurrentHashMap和AtomicInteger类组合。代码如下： 

    private Map<String, AtomicInteger> counter = new ConcurrentHashMap<>();

    public void countLog(NginxLog nginxLog) {
        String key = nginxLog.getHost() + separator + nginxLog.getDate();
        AtomicInteger oldValue = counter.putIfAbsent(key, new AtomicInteger(1));
        if (oldValue != null) {
            oldValue.incrementAndGet();
        }
    }

执行测试运行结果为： 

2017-11-28 14:53:14,655  INFO NginxLogCountTest - count: 100000, costTime: 11 ms

这种解决方案里面将AtomicInteger和ConcurrentHashMap组合到一起，counter.putIfAbsent()执行后可以获得当前值的AtomicInteger对象，这个时候使用AtomicInteger对象的incrementAndGet方法。这种组合相当于将两步操作分担给两个线程安全类来处理了。

从执行时间来看相对于单线程计数也还是有一定优势的。 

最后附上测试用的代码：

    @Resource
    private NginxLogCount nginxLogCount;

    @Test
    public void testCountLog() {
        NginxLog nginxLog = new NginxLog();
        nginxLog.setHost("test.com");
        nginxLog.setDate("2017-11-28T11:43:46+08:00");
        String key = nginxLog.getHost() + "|-|" + nginxLog.getDate();
        long startTime = System.currentTimeMillis();
        for (int j = 0; j < 10; j++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        nginxLogCount.countLog(nginxLog);
                    }
                }
            });
            thread.setDaemon(false);
            thread.start();
        }
        long endTime = System.currentTimeMillis();
        try {
            // 等待运行结束
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("count: {}, costTime: {} ms", nginxLogCount.getValue(key), endTime - startTime);
    }

    // getValue方法
    public int getValue(String key) {
        AtomicInteger value = counter.get(key);
        return value == null ? 0 : value.intValue();
    }