canal客户端使用多线程消费消息

最新推荐文章于 2024-09-17 15:04:10 发布

lattar one

最新推荐文章于 2024-09-17 15:04:10 发布

阅读量1.4k

点赞数

分类专栏： java mysql 文章标签： java mysql 数据库

本文链接：https://blog.csdn.net/qq_33321351/article/details/118675081

版权

java 同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

mysql

4 篇文章 0 订阅

订阅专栏

该博客探讨了Canal客户端在消费时由于单线程阻塞导致的线程利用率低的问题。作者提供了一个示例，通过使用线程池和定时任务来异步处理和确认Canal消息，以提高效率。示例中，消息被放入队列并由多个线程并行处理，然后根据处理结果进行批量ACK或ROLLBACK。同时，博客提到了批处理ID的乱序问题和避免重复确认的注意事项。

摘要由CSDN通过智能技术生成

由于canal消费时是单线程阻塞的，大大降低了程序对于线程的利用率
canal客户端实现官方demo
以下是通过线程池去消费canal订阅的消息代码

    //存放操作完后的batchId和结果
    private static ConcurrentHashMap<Long,Boolean> batchIdMap = new ConcurrentHashMap<>();
    //将需要消费的batchId按顺序存放队列中
    private volatile static LinkedBlockingQueue<Long> batchIds = new LinkedBlockingQueue<>();
	protected void process() {
        while (running) {
            connector.connect();
            connector.subscribe(canalInstance.getFilter());
            //创建线程去响应canal
            //定时通知canal消费是否成功
            Executors.newSingleThreadScheduledExecutor().scheduleWithFixedDelay(() -> {
                try {
                    while (true) {
                        if (CollectionUtils.isEmpty(batchIdMap) || batchIds.isEmpty()) {
                            return;
                        }
                        Long peek = batchIds.peek();
                        Boolean aBoolean = batchIdMap.get(peek);
                        if (null == aBoolean) {
                            return;
                        }
                        if (aBoolean) {
                            logger.info("canal ack batch-----{}", peek);
                            connector.ack(batchIds.poll());
                        } else {
                            logger.info("canal rollback batch-----{}", peek);
                            connector.rollback(batchIds.poll());
                        }
                        batchIdMap.remove(peek);
                    }
                } catch (Exception e) {
                    logger.error("scheduleWithFixedDelay", e);
                }
            }, 0, 10, TimeUnit.SECONDS);

            try {
                MDC.put("destination", canalInstance.getDestination());
                //定时通知canal消费是否成功
                while (running) {
                    // 获取指定数量的数据
                    Message message = connector.getWithoutAck(canalInstance.getBatchsize());
                    long batchId = message.getId();
                    int size = message.getEntries().size();
                    if ((batchId == -1 || size == 0)) {
                        continue;
                    }
                    logger.info("canal client execute batchId:{}, size:{}", batchId, size);
                    //往队列中添加消费的batchId
                    batchIds.add(message.getId());
                    //消费message
                    readMessage(message);
                }

            } catch (Exception e) {
                if(e instanceof CanalClientException){
                    CanalClientException canalClientException = (CanalClientException) e;
                    if(canalClientException.getCause() instanceof IOException || canalClientException.getCause() instanceof ConnectException){
                        logger.error("connector error!retry connector", e);
                        connector.connect();
                    }
                }
                logger.error("process error!", e);
            } finally {
                connector.disconnect();
                logger.info("connector destination");
                MDC.remove("destination");
            }
        }
    }
      /**
     * 读取message信息
     * @param message
     * @throws Exception
     */
    private void readMessage(Message message) throws Exception {
        //启动线程池
        threadPoolExecutorUtil.createThreadPoolExecutor().execute(() -> {
            try {
          		//具体的处理方法ing....返回是否成功
                boolean b = canalEntry(message.getEntries());
                logger.info("完成消费batchId========={}---Finished====={}---Size====={}",message.getId(),b,message.getEntries().size());
                //存放已经消费完成的batchId和是否成功
                batchIdMap.put(message.getId(),b);
            } catch (Exception e) {
                logger.error("consumeMessage", e);
                try {
                    Thread.sleep(1000);
                } catch (Exception e2) {}
            }
        });
    }