文章功能用户点击量统计，相信很多人会有接触到，那么如果避免数据库频繁的去做记录数+1的操作呢
下面介绍一种比较容易实现的方法，就是使用ReadWriteLock 读写分离并发工具
一切尽在代码中，代码如下：
精髓代码就是：
private ReadWriteLock lock = new ReentrantReadWriteLock(); //互斥锁
//读锁
try{
lock.readLock().lock();
...// 省略的代码
}finally{
lock.readLock().unlock();
}
//写锁
try{
lock.writeLock().lock();
...// 省略的代码
}finally{
lock.writeLock().unlock();
}
import org.apache.commons.lang3.RandomStringUtils;
import java.util.Map;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* Created by cailu on 2018/6/11.
*/
public class ReadWriteLockTest{
public static void main(String[] args) throws InterruptedException {
CountDownLatch start = new CountDownLatch(1);
CountDownLatch stop = new CountDownLatch(1);
for (int i = 0; i < 2; i++) {
Thread thread = new Thread(new RunMethod(start, stop));
thread.start();
}
start.countDown();//启动
stop.await();//等待所有结束
System.out.println("全部运行完毕！！！");
Thread.sleep(5000);//主要为了等最终的入库结果
ConcurrentHashMap<String, Integer> concurrentHashMap = Counter.getInst().getTotalCountMap();
int totalCount = 0;
System.out.println("=====入库数据汇总=====");
for (Map.Entry<String, Integer> entry : concurrentHashMap.entrySet()) {
System.out.println("入库数据汇总|" + entry.getKey() + "|" + entry.getValue());
totalCount += entry.getValue();
}
System.out.println("入库数据汇总|总和|" + totalCount);
}
static class RunMethod implements Runnable{
private CountDownLatch start;
private CountDownLatch stop;
public RunMethod(CountDownLatch start, CountDownLatch stop) {
this.start = start;
this.stop = stop;
}
public void run() {
try {
start.await();
for (int i = 0; i < 10000; i++) {
Counter.getInst().addClick(RandomStringUtils.random(1, "AB"));
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
stop.countDown();
}
}
}
static class Counter{
private ConcurrentHashMap<String, AtomicInteger> map = new ConcurrentHashMap<String, AtomicInteger>();
private ReadWriteLock lock = new ReentrantReadWriteLock(); //互斥锁
static class CounterHolder{
public static final Counter instance = new Counter();
}
public static Counter getInst(){
return CounterHolder.instance;
}
private Counter(){
//启动定时刷新数据库任务
//每20毫秒钟进行入库
ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
executorService.scheduleAtFixedRate(new Runnable() {
public void run() {
ConcurrentHashMap<String, AtomicInteger> tmpMap = null;
try {
lock.writeLock().lock();
tmpMap = map;
map = new ConcurrentHashMap<String, AtomicInteger>();
} finally {
lock.writeLock().unlock();
}
if (!tmpMap.isEmpty()) {
System.out.println("==================入库开始==================");
for (Map.Entry<String, AtomicInteger> entry : tmpMap.entrySet()) {
String key = entry.getKey();
int count = entry.getValue().get();
System.out.println("入库数据|" + key + "|" + count);
Integer tempCount = totalCountMap.get(key);
if (tempCount == null) {
totalCountMap.put(key, count);
} else {
totalCountMap.put(key, count + tempCount);
}
}
System.out.println("==================入库结束==================");
}
}
}, 0, 20, TimeUnit.MILLISECONDS);
}
//当用户点击了一次，就对数据点击量加一
public void addClick(String id) {
try{
lock.readLock().lock();
AtomicInteger atomicIntegerNew = new AtomicInteger(0);
AtomicInteger atomicInteger = map.putIfAbsent(id, atomicIntegerNew);
if(atomicInteger == null){//说明是新增
atomicInteger = atomicIntegerNew;
}
atomicInteger.addAndGet(1);
}finally{
lock.readLock().unlock();
}
}
//额外记录一下总数，看看是否正确
private ConcurrentHashMap<String, Integer> totalCountMap = new ConcurrentHashMap<String, Integer>();
public ConcurrentHashMap<String, Integer> getTotalCountMap() {
return totalCountMap;
}
}
}
测试结果如下：
==================入库开始==================
入库数据|A|3583
入库数据|B|3659
==================入库结束==================
全部运行完毕！！！
==================入库开始==================
入库数据|A|6374
入库数据|B|6384
==================入库结束==================
=====入库数据汇总=====
入库数据汇总|A|9957
入库数据汇总|B|10043
入库数据汇总|总和|20000
测试结果说明
我们开启了2个线程，分别访问10000次，得到的入库数据汇总总和也是20000，说明在并发环境数据统计是正确的。
现在，就开启你自己的ReadWriteLock旅程吧
