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();
     }