记一次使用ReentrantLock和Condition并发锁，对数据库批处理代码的优化

最新推荐文章于 2023-08-08 01:27:56 发布

乱世重生-归云

最新推荐文章于 2023-08-08 01:27:56 发布

阅读量266

点赞数

CC 4.0 BY-SA版权

文章标签： ReentrantLock Condition 并发锁批处理 JAVA

本文链接：https://blog.csdn.net/whj19870406/article/details/78808877

本文介绍了一种针对HBase的批量写入优化方案，通过使用ReentrantLock和Condition实现定时或定量的数据批量写入机制，有效提升写入效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

业务场景：

实时写hbase，但是每次写hbase都需要数据的传输和提交，所以希望可以改成批量写入。

这里有两个需求：

为了避免一次性写入很多，所以需要做上限的校验。

1.定时批量写入（即每个一段时间写入）；

2.定量批量写入（即超过一定数量上限后写入）；

优化后的代码如下（删除了一些不需要的代码）：

这里用到了ReentrantLock和Condition，Condition的逻辑其实类似于同步关键字里面对象锁，await()相当于wait()，signal()相当于notify();

同样，这两个函数的前提是获取锁，signal()只是标记一下释放的状态，真正的释放需要等待await()和unlock()函数才会触发。

class HbaseBatchSaveExecutor 
extends 
Thread implements Serializable {


    /**
     * 等待锁 
     */
    ReentrantLock wait = new ReentrantLock();
    Condition overLimit = wait.newCondition();


    /**
     * 间隔时间
     */
    private long intervalTime = 0;


    private int overLimitNum = 0;


    volatile int

perCycleNum 
= 
0;


    /**
     *
     * @param overLimitNum  存储的数量上限，超过这个数 可以进行数据存储了 默认500条
     * @param intervalTime 超时上限，超过这个时间 也可以进行数据存储了 默认1000ms
     */
    public HbaseBatchSaveExecutor(Integer overLimitNum, Long intervalTime){
        if(intervalTime == null){
            this.intervalTime = 1000L;
        }else{
            this.intervalTime = intervalTime;
        }
        if(overLimitNum == null){
            this.overLimitNum = 500;
        }else{
            this.overLimitNum = overLimitNum;
        }
    }


    public boolean add(...){
        try {
            ...


            //数量累加，超过上限时通知取消等待
            if(perCycleNum++ > overLimitNum){
                signalOverLimit();
            }
            return true;
        }catch (Exception e){
            //打印日志
            return false;
        }
    }
    
    @Override
    public void run() {
        while(true){


            lockAndWait();
                      
            //做其他事情
        }
    }




    /**
     * 锁并等待
     */
    private void lockAndWait() {
        try{
            wait.lockInterruptibly();
            //获取锁，并进入等待 释放锁
            overLimit.await(intervalTime, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            //异常捕获
        } finally {
            //这里一定要释放锁
            wait.unlock();
        }
    }


    private void signalOverLimit() {
        //和同步关键字一样，如果需要发送信号，需要先获取锁
        wait.lock();
        try {
            //发送信号
            overLimit.signal();
        } finally {
            //这里才会真正的通知 之前await()的线程
            wait.unlock();
        }
    }


    //其他一些代码...


}