[zmq]-消息中间件，循环队列

最新推荐文章于 2025-05-03 10:56:02 发布

yan0219n

最新推荐文章于 2025-05-03 10:56:02 发布

阅读量188

点赞数

文章标签： java spring jvm

本文链接：https://blog.youkuaiyun.com/xiao320321/article/details/130413266

版权

该文章展示了一个基于ZMQ的消费者实现，它使用Dealer模式连接到生产者，并通过ExecutorService创建工作线程池来处理接收到的数据。然后，文章进一步介绍了如何使用Disruptor和RingBuffer来替代线程池，以提高数据处理的效率和并发性能。

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

import org.zeromq.SocketType;
import org.zeromq.ZContext;
import org.zeromq.ZMQ;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ZMQConsumer {

    private static final String ENDPOINT = "tcp://localhost:5555";
    private static final int NUM_WORKERS = 4;

    public static void main(String[] args) {
        // 创建ZeroMQ上下文
        try (ZContext context = new ZContext()) {
            // 创建Dealer模式的套接字
            ZMQ.Socket socket = context.createSocket(SocketType.DEALER);
            // 连接到生产者端点
            socket.connect(ENDPOINT);

            // 创建工作线程池
            ExecutorService workerThreadPool = Executors.newFixedThreadPool(NUM_WORKERS);

            for (int i = 0; i < NUM_WORKERS; i++) {
                workerThreadPool.submit(new Worker(context, socket));
            }

            // 循环监听套接字的事件
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    // 从套接字接收数据
                    byte[] data = socket.recv();
                    
                    // 将数据发送给工作线程池处理
                    workerThreadPool.submit(() -> {
                        // 对数据进行处理
                        // ...
                        // 将结果发送回生产者
                        socket.send(data);
                    });
                } catch (ZMQException e) {
                    if (!e.getMessage().contains("Operation cannot be accomplished in current state")) {
                        throw e;
                    }
                }
            }

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    private static class Worker implements Runnable {
        private final ZMQ.Socket workerSocket;

        public Worker(ZContext context, ZMQ.Socket socket) {
            this.workerSocket = context.createSocket(SocketType.DEALER);
            // 连接到生产者端点
            this.workerSocket.connect(ENDPOINT);
        }

        @Override
        public void run() {
            while (true) {
                try {
                    // 从队列中取出任务
                    Runnable task = workerThreadPool.take();
                    // 执行任务
                    task.run();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
}

优化的代码

import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.dsl.Disruptor;
import org.zeromq.SocketType;
import org.zeromq.ZContext;
import org.zeromq.ZMQ;

import java.util.concurrent.Executors;

public class ZMQConsumer {

    private static final String ENDPOINT = "tcp://localhost:5555";
    private static final int NUM_WORKERS = 4;
    private static final int BUFFER_SIZE = 1024;

    public static void main(String[] args) {
        // 创建ZeroMQ上下文
        try (ZContext context = new ZContext()) {
            // 创建Dealer模式的套接字
            ZMQ.Socket socket = context.createSocket(SocketType.DEALER);
            // 连接到生产者端点
            socket.connect(ENDPOINT);

            // 创建Disruptor实例
            Disruptor<byte[]> disruptor = new Disruptor<>(() -> new byte[BUFFER_SIZE], BUFFER_SIZE, Executors.defaultThreadFactory());
            RingBuffer<byte[]> ringBuffer = disruptor.getRingBuffer();

            // 创建工作线程池
            for (int i = 0; i < NUM_WORKERS; i++) {
                disruptor.handleEventsWith(new Worker(context, socket));
            }

            // 启动Disruptor
            disruptor.start();

            // 循环监听套接字的事件
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    // 从套接字接收数据
                    byte[] data = socket.recv();

                    // 将数据添加到Disruptor中
                    long sequence = ringBuffer.next();
                    try {
                        byte[] buffer = ringBuffer.get(sequence);
                        System.arraycopy(data, 0, buffer, 0, data.length);
                    } finally {
                        ringBuffer.publish(sequence);
                    }
                } catch (ZMQException e) {
                    if (!e.getMessage().contains("Operation cannot be accomplished in current state")) {
                        throw e;
                    }
                }
            }

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    private static class Worker implements EventHandler<byte[]> {
        private final ZMQ.Socket workerSocket;

        public Worker(ZContext context, ZMQ.Socket socket) {
            this.workerSocket = context.createSocket(SocketType.DEALER);
            // 连接到生产者端点
            this.workerSocket.connect(ENDPOINT);
        }

        @Override
        public void onEvent(byte[] data, long sequence, boolean endOfBatch) {
            // 对数据进行处理
            // ...

            // 将结果发送回生产者
            workerSocket.send(data);
        }
    }
}