消息队列RabbitMQ中多路复用Channel的理解

最新推荐文章于 2023-04-19 19:22:41 发布

swordbob

最新推荐文章于 2023-04-19 19:22:41 发布

阅读量5.3k

点赞数 6

分类专栏： JAVA 文章标签： socket 队列 java

本文链接：https://blog.csdn.net/njq774327136/article/details/117755506

版权

JAVA 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

什么叫消息队列

消息（Message）是指在应用间传送的数据。消息可以非常简单，比如只包含文本字符串，也可以更复杂，可能包含嵌入对象。

消息队列（Message Queue）是一种应用间的通信方式，消息发送后可以立即返回，由消息系统来确保消息的可靠传递。消息发布者只管把消息发布到 MQ 中而不用管谁来取，消息使用者只管从 MQ 中取消息而不管是谁发布的。这样发布者和使用者都不用知道对方的存在。

最简单的理解是开了两个定时器的线程，分别是上传参数和下载数据两个不同的线程，他们之间通过数据库（也就是这里的queue）进行异步联通，但这里并不是用的定时器而是用的观察者模式

RabbitMQ 基本概念

上面只是最简单抽象的描述，具体到 RabbitMQ 则有更详细的概念需要解释。上面介绍过 RabbitMQ 是 AMQP 协议的一个开源实现，所以其内部实际上也是 AMQP 中的基本概念：

RabbitMQ 内部结构

Message
消息，消息是不具名的，它由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括routing-key（路由键）、priority（相对于其他消息的优先权）、delivery-mode（指出该消息可能需要持久性存储）等。
Publisher
消息的生产者，也是一个向交换器发布消息的客户端应用程序。
Exchange
交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。
Binding
绑定，用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。
Queue
消息队列，用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息可投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。
Connection
网络连接，比如一个TCP连接。
Channel
信道，多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内地虚拟连接，AMQP 命令都是通过信道发出去的，不管是发布消息、订阅队列还是接收消息，这些动作都是通过信道完成。因为对于操作系统来说建立和销毁 TCP 都是非常昂贵的开销，所以引入了信道的概念，以复用一条 TCP 连接。
Consumer
消息的消费者，表示一个从消息队列中取得消息的客户端应用程序。
Virtual Host
虚拟主机，表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器，拥有自己的队列、交换器、绑定和权限机制。vhost 是 AMQP 概念的基础，必须在连接时指定，RabbitMQ 默认的 vhost 是 / 。
Broker
表示消息队列服务器实体。

对于理解多路复用，需要讲下NIO:

其实，多路复用是一种思想，多路是指多个客户端连接线路（TCP、Channel），复用是指使用一个线程重复使用，总的来说，就是单线程能同时处理多个请求。要实现这一点，就得改造BIO的连接模式了，BIO是客户端直接连接服务端，NIO采用的是多路复用器 (Selector)，相当于客户端的连接不会直接连接服务端，而是连接到多路复用器。

这样做的好处，就是把服务端和客户端隔离了，如果不直接连接，服务器端就不会阻塞，多路复用器会将收到的消息做为事件请求发送给服务端，但服务端在处理事件的时候对于其他客户端来说还是阻塞的，这些事件有不同类型。

事件类型   事件常量   常量值   事件判断
连接事件   SelectionKey.OP_CONNECT   1 << 3   SelectionKey.isConnectable()
接收事件   SelectionKey.OP_ACCEPT   1 << 4   SelectionKey.isAcceptable()
读事件   SelectionKey.OP_READ   1 << 0   SelectionKey.isReadable()
写事件   SelectionKey.OP_WRITE   1 << 2   SelectionKey.isWritable()

Channel
了解了多路复用这个设计后，再讲下Channel部分，Channel是一个双向读写通道，是异步传输的，基于数据块结构传输，BIO使用的是Stream流，基于字节传输。

功能   Stream   Channel
异步传输   不支持   支持
传输方式   按字节传输   按块传输
双向读写   不支持，读写需要分别使用InputStream、OutputStream   支持，能读能写
缓冲   BufferStream/Buffered   ByteBuffer/CharBuffer/DoubleBuffer…(省略)

关于性能方面，我也没做过测试，但我知道一口咬定NIO比BIO性能要高效的言论，是错误的，NIO主要解决的不是性能的问题
Channel有很多实现，因为本文介绍的是Socket，客户端使用SocketChannel，服务端使用ServerSocketChannel

代码实现
服务端：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class NioServer {

public static void main(String[] args) throws IOException, InterruptedException {
// 打开Channel服务端并绑定监听一个端口
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.socket().bind(new InetSocketAddress(8459));
ssc.configureBlocking(false);

// 打开多路复用器并注册到 ServerSocketChannel 并监听连接事件
Selector selector = Selector.open();
ssc.register(selector, SelectionKey.OP_ACCEPT);

System.out.println("服务器已启动...");
while (true) {
// 如果没有事件发生则select() 处于阻塞状态
selector.select();
// 发生事件
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
// 处理事件
while (iterator.hasNext()) {
// 拿到具体事件
SelectionKey selectionKey = iterator.next();

// 判断事件的类型
if (selectionKey.isAcceptable()) {
System.out.println("客户端连接事件");
SocketChannel channel = ssc.accept();
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ);
if (channel.finishConnect()) {
System.out.println("完成连接");
}
} else if (selectionKey.isReadable()) {
SocketChannel sc = (SocketChannel) selectionKey.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int read = sc.read(buffer);
System.out.println("收到的消息:" + new String(buffer.array(), 0, read));

// 响应客户端这里可有可无
buffer.clear();
buffer.put("已收到消息".getBytes());
// 将缓冲区各标志复位，因为向里面put了数据标志被改变要想从中读取数据发向服务器，就要复位
buffer.flip();
sc.write(buffer);
// 设置监听事件的集合这里把写入事件加入
selectionKey.interestOps(selectionKey.interestOps() | SelectionKey.OP_WRITE);
System.out.println("服务器向客户端发送已确认消息");

} else if (selectionKey.isWritable()) {
System.out.println("触发往客户端写入数据事件");
// 发送完了就取消监听写事件，否则会无限循环触发写事件
selectionKey.interestOps(selectionKey.interestOps() & ~SelectionKey.OP_WRITE);
}

// 事件完成后，将其移除
iterator.remove();
}
}
}

客户端

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

public class NioClient {

public static void main(String[] args) throws IOException {
//打开选择器
Selector selector = Selector.open();
//打开通道
SocketChannel socketChannel = SocketChannel.open();
//配置非阻塞模型
socketChannel.configureBlocking(false);
//连接远程主机
socketChannel.connect(new InetSocketAddress("127.0.0.1", 8459));
//注册事件
socketChannel.register(selector, SelectionKey.OP_CONNECT | SelectionKey.OP_READ );

//循环处理
new Thread(() -> {
while (true) {
try {
selector.select();
Set<SelectionKey> keys = selector.selectedKeys();
Iterator<SelectionKey> iter = keys.iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
if (key.isConnectable()) {
//连接建立或者连接建立不成功
SocketChannel channel = (SocketChannel) key.channel();
//完成连接的建立
if (channel.finishConnect()) {
System.out.println("完成连接");
}
} else if (key.isReadable()) {
SocketChannel channel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.clear();
channel.read(buffer);
System.out.println("客户端收到消息:" + new String(buffer.array()));
key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
} else if (key.isWritable()) {
System.out.println("客户端向服务端写入数据");
// 设置监听事件的集合这里把写入事件加入
key.interestOps(key.interestOps() & ~SelectionKey.OP_WRITE);
}
iter.remove();
}
} catch (IOException e) {
e.printStackTrace();
break;
}
}
}).start();
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("请输入要发送的字符串");
String str = scanner.nextLine();
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put(str.getBytes());
buffer.flip();
socketChannel.write(buffer);
}
}
}

讲完多路复用，接下来就是TCP实现的多路复用，整体和NIO很相似，都是把请求注册到selector中，根据SelectionKey进行阻塞式的通信，因为有了注册和SelectionKey使得单线程能同时处理多个请求成为可能

IO多路复用(multiplexing)属于同步IO网络模型

是以Reactor模式实现

常见的IO多路复用应用有：select、poll、epoll

有关于select的应用方式，请参阅[C语言] 基于Linux的一对一Socket简易聊天程序实例

本篇文章采用Java的NIO框架来实现单线程的IO多路复用

2. Reactor模式的组成角色

1. Reactor：负责派发IO事件给对应的角色处理。为了监听IO事件，select必须实现在Reactor中。

2. Acceptor：负责接受client的连线，然后给client绑定一个Handler并注册IO事件到Reactor上监听。

3. Handler：负责处理与client交互的事件或行为。通常因为Handler要处理与所对应client交互的多个事件或行为，为了简化设计，会以状态模式来实现Handler。

3. 代码实现

[TCPReactor.java]

// Reactor線程
package server;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.util.Iterator;
import java.util.Set;
public class TCPReactor implements Runnable {
private final ServerSocketChannel ssc;
private final Selector selector;
public TCPReactor(int port) throws IOException {
selector = Selector.open();
ssc = ServerSocketChannel.open();
InetSocketAddress addr = new InetSocketAddress(port);
ssc.socket().bind(addr); // 在ServerSocketChannel綁定監聽端口
ssc.configureBlocking(false); // 設置ServerSocketChannel為非阻塞
SelectionKey sk = ssc.register(selector, SelectionKey.OP_ACCEPT); // ServerSocketChannel向selector註冊一個OP_ACCEPT事件，然後返回該通道的key
sk.attach(new Acceptor(selector, ssc)); // 給定key一個附加的Acceptor對象
}
@Override
public void run() {
while (!Thread.interrupted()) { // 在線程被中斷前持續運行
System.out.println("Waiting for new event on port: " + ssc.socket().getLocalPort() + "...");
try {
if (selector.select() == 0) // 若沒有事件就緒則不往下執行
continue;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Set<SelectionKey> selectedKeys = selector.selectedKeys(); // 取得所有已就緒事件的key集合
Iterator<SelectionKey> it = selectedKeys.iterator();
while (it.hasNext()) {
dispatch((SelectionKey) (it.next())); // 根據事件的key進行調度
it.remove();
}
}
}
/*
* name: dispatch(SelectionKey key)
* description: 調度方法，根據事件綁定的對象開新線程
*/
private void dispatch(SelectionKey key) {
Runnable r = (Runnable) (key.attachment()); // 根據事件之key綁定的對象開新線程
if (r != null)
r.run();
}
}

[Acceptor.java]

// 接受連線請求線程
package server;
import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
public class Acceptor implements Runnable {
private final ServerSocketChannel ssc;
private final Selector selector;
public Acceptor(Selector selector, ServerSocketChannel ssc) {
this.ssc=ssc;
this.selector=selector;
}
@Override
public void run() {
try {
SocketChannel sc= ssc.accept(); // 接受client連線請求
System.out.println(sc.socket().getRemoteSocketAddress().toString() + " is connected.");
if(sc!=null) {
sc.configureBlocking(false); // 設置為非阻塞
SelectionKey sk = sc.register(selector, SelectionKey.OP_READ); // SocketChannel向selector註冊一個OP_READ事件，然後返回該通道的key
selector.wakeup(); // 使一個阻塞住的selector操作立即返回
sk.attach(new TCPHandler(sk, sc)); // 給定key一個附加的TCPHandler對象
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

我们先来简单点的，Handler不以状态模式实现，只以比较直觉的方式实现。

[TCPHandler.java]

// Handler線程
package server;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class TCPHandler implements Runnable {
private final SelectionKey sk;
private final SocketChannel sc;
int state;
public TCPHandler(SelectionKey sk, SocketChannel sc) {
this.sk = sk;
this.sc = sc;
state = 0; // 初始狀態設定為READING
}
@Override
public void run() {
try {
if (state == 0)
read(); // 讀取網絡數據
else
send(); // 發送網絡數據
} catch (IOException e) {
System.out.println("[Warning!] A client has been closed.");
closeChannel();
}
}
private void closeChannel() {
try {
sk.cancel();
sc.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
private synchronized void read() throws IOException {
// non-blocking下不可用Readers，因為Readers不支援non-blocking
byte[] arr = new byte[1024];
ByteBuffer buf = ByteBuffer.wrap(arr);
int numBytes = sc.read(buf); // 讀取字符串
if(numBytes == -1)
{
System.out.println("[Warning!] A client has been closed.");
closeChannel();
return;
}
String str = new String(arr); // 將讀取到的byte內容轉為字符串型態
if ((str != null) && !str.equals(" ")) {
process(str); // 邏輯處理
System.out.println(sc.socket().getRemoteSocketAddress().toString()
+ " > " + str);
state = 1; // 改變狀態
sk.interestOps(SelectionKey.OP_WRITE); // 通過key改變通道註冊的事件
sk.selector().wakeup(); // 使一個阻塞住的selector操作立即返回
}
}
private void send() throws IOException {
// get message from message queue
String str = "Your message has sent to "
+ sc.socket().getLocalSocketAddress().toString() + "\r\n";
ByteBuffer buf = ByteBuffer.wrap(str.getBytes()); // wrap自動把buf的position設為0，所以不需要再flip()
while (buf.hasRemaining()) {
sc.write(buf); // 回傳給client回應字符串，發送buf的position位置到limit位置為止之間的內容
}
state = 0; // 改變狀態
sk.interestOps(SelectionKey.OP_READ); // 通過key改變通道註冊的事件
sk.selector().wakeup(); // 使一個阻塞住的selector操作立即返回
}
void process(String str) {
// do process(decode, logically process, encode)..
// ..
}
}

最后是主程序代码

[Main.java]

package server;
import java.io.IOException;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
TCPReactor reactor = new TCPReactor(1333);
reactor.run();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

下面附上客戶端代碼：

[Client.java]

package main.pkg;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String hostname=args[0];
int port = Integer.parseInt(args[1]);
//String hostname="127.0.0.1";
//int port=1333;
System.out.println("Connecting to "+ hostname +":"+port);
try {
Socket client = new Socket(hostname, port); // 連接至目的地
System.out.println("Connected to "+ hostname);
PrintWriter out = new PrintWriter(client.getOutputStream());
BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
String input;
while((input=stdIn.readLine()) != null) { // 讀取輸入
out.println(input); // 發送輸入的字符串
out.flush(); // 強制將緩衝區內的數據輸出
if(input.equals("exit"))
{
break;
}
System.out.println("server: "+in.readLine());
}
client.close();
System.out.println("client stop.");
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
System.err.println("Don't know about host: " + hostname);
} catch (IOException e) {
// TODO Auto-generated catch block
System.err.println("Couldn't get I/O for the socket connection");
}
}
}

swordbob

关注

6
点赞
踩
14

收藏

觉得还不错? 一键收藏
打赏
3
评论
消息队列RabbitMQ中多路复用Channel的理解

RabbitMQ 基本概念上面只是最简单抽象的描述，具体到 RabbitMQ 则有更详细的概念需要解释。上面介绍过 RabbitMQ 是 AMQP 协议的一个开源实现，所以其内部实际上也是 AMQP 中的基本概念：RabbitMQ 内部结构Message 消息，消息是不具名的，它由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括routing-key（路由键）、priority（相对于其他消息的优先权）、delivery-mode（指出该消息可能需要持久
复制链接

扫一扫