1、基本依赖
- 导入MQ客户端依赖
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-client</artifactId>
<version>4.4.0</version>
</dependency>- 消息发送者步骤
1.创建消息生产者producer，并制定生产者组名
2.指定Nameserver地址
3.启动producer
4.创建消息对象，指定主题Topic、Tag和消息体
5.发送消息
6.关闭生产者producer- 消息消费者步骤
1.创建消费者Consumer，制定消费者组名
2.指定Nameserver地址
3.订阅主题Topic和Tag
4.设置回调函数，处理消息
5.启动消费者consumer2、基本消息
2.1、消息发送
2.1.1、发送同步消息
这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。
@Test
/**
* 简单生产发送者
*/
public void simpleMQProducer() throws Exception {
// 1、创建生产者
DefaultMQProducer producer = new DefaultMQProducer("SimpleMQProducer");
// 2、设置NameServer地址
producer.setNamesrvAddr(SERVER_ADDR);
// 3、启动生产者
producer.start();
for (int i = 0; i < 100; i++) {
// 4、创建消费者，指定topic、tag
Message message = new Message(
"SimpleTopic",
"SimpleTag",
("Simple message " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
// 5、发送消息
SendResult result = producer.send(message);
System.out.println(result);
}
// 6、关闭生产者
producer.shutdown();
}2.1.2、发送异步消息
异步消息通常用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。
@Test
/**
* 异步MQ生产者
*/
public void asynMQProducer() throws Exception {
DefaultMQProducer producer = new DefaultMQProducer("AsynMQProducer");
producer.setNamesrvAddr(SERVER_ADDR);
producer.start();
// 异步发送失败的重试次数（默认为2）
producer.setRetryTimesWhenSendAsyncFailed(0);
for (int i = 0; i < 100; i++) {
Message message = new Message(
"AsynTopic",
"AsynTag",
("Asyn message " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
// 接收异步返回的回调
producer.send(message, new SendCallback() {
@Override
public void onSuccess(SendResult sendResult) {
int index = asynIndex.addAndGet(1);
System.out.printf("异步 %d 回调: %s \n", index, sendResult);
}
@Override
public void onException(Throwable e) {
asynIndex.addAndGet(1);
}
});
}
while (true) {
if (asynIndex.get() == 100) {
// 保证消息都处理完毕
break;
}
}
producer.shutdown();
}2.1.3、单向发送消息
这种方式主要用在不特别关心发送结果的场景，例如日志发送。
@Test
/**
* 单向消息发送者
*/
public void oneWayMQProducer() throws Exception {
DefaultMQProducer producer = new DefaultMQProducer("OneWayMQProducer");
producer.setNamesrvAddr(SERVER_ADDR);
producer.start();
for (int i = 0; i < 100; i++) {
Message message = new Message(
"OneWayTopic",
"OneWayTag",
("OneWay message " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
// 发送单向消息，没有返回结果
producer.sendOneway(message);
}
producer.shutdown();
}2.2、消息消费
2.2.1、负载均衡模式
消费者采用负载均衡方式消费消息，多个消费者共同消费队列消息，每个消费者处理的消息不同
@Test
/**
* 负载均衡消费消息
*/
public void loadBalanceConsumer() throws Exception {
// 1、创建消费者，并指定消费者组
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("LoadBalanceConsumer");
// 2、指定namesrv地址
consumer.setNamesrvAddr(SERVER_ADDR);
// 3、订阅Topic、Tag
consumer.subscribe("SimpleTopic", "*");
// 4、负载均衡消费
consumer.setMessageModel(MessageModel.CLUSTERING);
// 5、注册回调函数，处理消息
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
System.out.printf("%s 处理消息：%s \n", Thread.currentThread().getName(), msgs);
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
// 6、启动消息
consumer.start();
System.out.println("消息启动");
System.in.read();
}2.2.2、广播模式
消费者采用广播的方式消费消息，每个消费者消费的消息都是相同的
@Test
/**
* 广播方式消费者
*/
public void broadCastMQConsumer() throws Exception {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("BroadCastMQConsumer");
consumer.setNamesrvAddr(SERVER_ADDR);
consumer.subscribe("SimpleTopic", "*");
consumer.setMessageModel(MessageModel.BROADCASTING);
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
System.out.printf("%s 消费消息：%s \n", Thread.currentThread().getName(), msgs);
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
consumer.start();
System.out.println("消息启动");
System.in.read();
}3、顺序消息
消息有序指的是可以按照消息的发送顺序来消费(FIFO)。RocketMQ可以严格的保证消息有序，可以分为分区有序或者全局有序。
顺序消费的原理解析，在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)；而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。但是如果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上依次拉取，则就保证了顺序。当发送和消费参与的queue只有一个，则是全局有序；如果多个queue参与，则为分区有序，即相对每个queue，消息都是有序的。
下面用订单进行分区有序的示例。一个订单的顺序流程是：创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中，消费时，同一个OrderId获取到的肯定是同一个队列。
3.1、顺序消息生产
@Test
/**
* 有序消息发送者
*/
public void orderMQProducer() throws Exception {
DefaultMQProducer producer = new DefaultMQProducer("OrderMQProducer");
producer.setNamesrvAddr(SERVER_ADDR);
producer.start();
String[] tags = new String[]{"TagA", "TagB", "TagC"};
// 模拟订单列表
List<HashMap<String, String>> orderList = new ArrayList<HashMap<String, String>>() {
{
add(new HashMap<String, String>() {{
put("orderId", "10010");
put("desc", "创建");
}});
add(new HashMap<String, String>() {{
put("orderId", "10011");
put("desc", "创建");
}});
add(new HashMap<String, String>() {{
put("orderId", "10012");
put("desc", "创建");
}});
add(new HashMap<String, String>() {{
put("orderId", "10010");
put("desc", "付款");
}});
add(new HashMap<String, String>() {{
put("orderId", "10011");
put("desc", "付款");
}});
add(new HashMap<String, String>() {{
put("orderId", "10012");
put("desc", "付款");
}});
add(new HashMap<String, String>() {{
put("orderId", "10010");
put("desc", "推送");
}});
add(new HashMap<String, String>() {{
put("orderId", "10011");
put("desc", "推送");
}});
add(new HashMap<String, String>() {{
put("orderId", "10012");
put("desc", "推送");
}});
add(new HashMap<String, String>() {{
put("orderId", "10010");
put("desc", "完成");
}});
add(new HashMap<String, String>() {{
put("orderId", "10011");
put("desc", "完成");
}});
add(new HashMap<String, String>() {{
put("orderId", "10012");
put("desc", "完成");
}});
}
};
for (int i = 0; i < orderList.size(); i++) {
String body = "Order message" + orderList.get(i);
Message message = new Message(
"OrderTopic",
tags[i % tags.length],
body.getBytes(RemotingHelper.DEFAULT_CHARSET));
SendResult result = producer.send(message, new MessageQueueSelector() {
@Override
public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
Long id = Long.valueOf(String.valueOf(arg));//根据id选择发送的queue
long index = id % mqs.size();
return mqs.get((int) index);
}
}, orderList.get(i).get("orderId"));
System.out.printf("消息发送状态：%s,消息队列id：%s,消息内容：%s %n",
result.getSendStatus(),
result.getMessageQueue().getQueueId(),
body);
}
producer.shutdown();
}3.2、顺序消息消费
@Test
/**
* 有序消息消费者
*/
public void orderMQConsumer() throws Exception {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("OrderMQConsumer");
consumer.setNamesrvAddr(SERVER_ADDR);
/**
* 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
* 如果非第一次启动，那么按照上次消费的位置继续消费
*/
consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
consumer.subscribe("OrderTopic", "TagA || TagB || TagC");
consumer.registerMessageListener(new MessageListenerOrderly() {
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
context.setAutoCommit(true);
for (MessageExt msg : msgs) {
System.out.printf("当前线程：%s,当前消息队列id：%s，内容：%s %n", Thread.currentThread().getName(), msg.getQueueId(), new String(msg.getBody()));
}
return ConsumeOrderlyStatus.SUCCESS;
}
});
consumer.start();
System.out.println("消费者启动");
System.in.read();
}4、延时消息
比如电商里，提交了一个订单就可以发送一个延时消息，1h后去检查这个订单的状态，如果还是未付款就取消订单释放库存。
4.1、启动消息消费者
@Test
/**
* 延时消息消费者
*/
public void scheduleMQConsumer() throws Exception {
// 1、创建消费者
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("ScheduleMQConsumer");
// 2、设置NameServer地址
consumer.setNamesrvAddr(SERVER_ADDR);
// 3、指定订阅Topic、Tag
consumer.subscribe("ScheduleTopic", "*");
// 4、注册处理函数
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
for (MessageExt msg : msgs) {
System.out.printf("当前线程：%s,当前时间：%s，当前内容：%s %n",
Thread.currentThread().getName(),
new SimpleDateFormat("HH:mm:ss").format(new Date()),
new String(msg.getBody()));
}
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
// 5、启动消费者
consumer.start();
System.out.println("消费者启动");
System.in.read();
}4.2、发送延时消息
@Test
/**
* 延时消息生产者
*/
public void scheduleMQProducer() throws Exception {
DefaultMQProducer producer = new DefaultMQProducer("ScheduleMQProducer");
producer.setNamesrvAddr(SERVER_ADDR);
producer.start();
Message message = new Message(
"ScheduleTopic",
"ScheduleTag",
("生产时间:" + new SimpleDateFormat("HH:mm:ss").format(new Date())).getBytes(RemotingHelper.DEFAULT_CHARSET));
// 设置延时等级10s
// 默认如下：String messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";
message.setDelayTimeLevel(3);
producer.send(message);
System.out.println("发送消息");
producer.shutdown();
}4.3、使用限制
// org/apache/rocketmq/store/config/MessageStoreConfig.java
private String messageDelayLevel = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";现在RocketMq并不支持任意时间的延时，需要设置几个固定的延时等级，从1s到2h分别对应着等级1到18
5、批量消息
批量发送消息能显著提高传递小消息的性能。限制是这些批量消息应该有相同的topic，相同的waitStoreMsgOK，而且不能是延时消息。此外，这一批消息的总大小不应超过4MB。
5.1、发送批量消息
@Test
/**
* 批量消息生产者
*/
public void batchMQProducer() throws Exception {
DefaultMQProducer producer = new DefaultMQProducer("BatchMQProducer");
producer.setNamesrvAddr(SERVER_ADDR);
producer.start();
List<Message> messageList = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
messageList.add(new Message(
"BatchTopic",
"BatchTag",
("Batch message " + i).getBytes(RemotingHelper.DEFAULT_CHARSET)));
}
/*进行消息拆解*/
MessageSplit msgSplit = new MessageSplit(messageList);
while (msgSplit.hasNext()) {
producer.send(msgSplit.next());
}
producer.shutdown();
System.out.println("批量消息发送成功");
}
@Test
/**
* 批量消息消费者
*/
public void batchMQConsumer() throws Exception {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("BatchMQConsumer");
consumer.setNamesrvAddr(SERVER_ADDR);
consumer.subscribe("BatchTopic", "*");
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
for (MessageExt msg : msgs) {
System.out.printf("当前线程：%s，消息内容：%s %n",
Thread.currentThread().getName(),
new String(msg.getBody()));
}
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
consumer.start();
System.out.println("消费者启动成功");
System.in.read();
}
public class MessageSplit implements Iterator {
private final Integer limitSize = 1024;
private Boolean isSplit = false;
private List<Message> messageList;
private Integer currentIndex = 0;
public MessageSplit(List<Message> messageList) {
this.messageList = messageList;
}
@Override
public boolean hasNext() {
return currentIndex < messageList.size();
}
@Override
public List<Message> next() {
Integer nextIndex = currentIndex;
Integer totalSize = 0;
for (; nextIndex < messageList.size(); nextIndex++) {
Message message = messageList.get(nextIndex);
AtomicInteger tempSize = new AtomicInteger(message.getTopic().length() + message.getBody().length);
message.getProperties().entrySet().parallelStream().forEach(entry -> {
tempSize.addAndGet(entry.getKey().length());
tempSize.addAndGet(entry.getValue().length());
});
if (tempSize.get() > limitSize) {
//单个消息超过了最大的限制
//忽略,否则会阻塞分裂的进程
if (nextIndex - currentIndex == 0) {
//假如下一个子列表没有元素,则添加这个子列表然后退出循环,否则只是退出循环
nextIndex++;
}
break;
}
if ((totalSize = tempSize.get() + totalSize) > limitSize) {
break;
}
}
List<Message> msgSublit = messageList.subList(currentIndex, nextIndex);
currentIndex = nextIndex;
return msgSublit;
}
}6、过滤消息
在大多数情况我们可以使用Tag来选择想要的消息。
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("Union_Consumer_Group");
consumer.subscribe("TOPIC", "TAGA || TAGB || TAGC");同事mq提供了一个基于sql语法的过滤机制。
6.1、过滤sql语法
RocketMQ只定义了一些基本语法来支持这个特性。你也可以很容易地扩展它。
只有push模式的消费者才能用使用SQL92标准的sql语句。
public void subscribe(finalString topic, final MessageSelector messageSelector)- 数值比较，比如：>，>=，<，<=，BETWEEN，=；
- 字符比较，比如：=，<>，IN；
- IS NULL 或者 IS NOT NULL；
- 逻辑符号 AND，OR，NOT；
常量支持类型为：
- 数值，比如：123，3.1415；
- 字符，比如：'abc'，必须用单引号包裹起来；
- NULL，特殊的常量
- 布尔值，TRUE 或 FALSE
6.2、消息生产者
发送消息时，你能通过putUserProperty来设置消息的属性
@Test
/**
* 过滤消息生产者
*/
public void filterMQProducer() throws Exception {
DefaultMQProducer producer = new DefaultMQProducer("FilterMQProducer");
producer.setNamesrvAddr(SERVER_ADDR);
producer.start();
for (int i = 0; i < 10; i++) {
Message message = new Message(
"FilterTopic",
"FilterTag",
("Filter message " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
message.putUserProperty("index", String.valueOf(i));
producer.send(message);
}
producer.shutdown();
System.out.println("消息发送成功");
}6.3、消息消费者
用MessageSelector.bySql来使用sql筛选消息
@Test
/**
* 过滤消息消费
*/
public void filterMQConsumer() throws Exception {
Consumer<String> mqConsumer = (tempSql) -> {
// 1、创建消费者组
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("FilterMQConsumer" + indexTag.getAndAdd(1));
try {
// 2、设置NameServier服务器地址
consumer.setNamesrvAddr(SERVER_ADDR);
// 3、订阅设置过滤条件
consumer.subscribe("FilterTopic", MessageSelector.bySql(tempSql));
// 4、注册消息响应函数
consumer.registerMessageListener(new MessageListenerConcurrently() {
@Override
public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
msgs.forEach(msg -> {
System.out.printf("规则：%s,当前线程：%s，消息内容：%s %n",
tempSql,
Thread.currentThread().getName(),
new String(msg.getBody()));
});
return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});
// 5、启动消费者
consumer.start();
} catch (MQClientException e) {
e.printStackTrace();
}
};
mqConsumer.accept("index < 3");
mqConsumer.accept("index between 3 and 5");
mqConsumer.accept("index > 5");
System.out.println("消费者启动成功");
System.in.read();
}7、事务消息
7.1、流程分析
其中分为两个流程：正常事务消息的发送及提交、事务消息的补偿流程。
7.1.1、事务消息发送及提交
(1) 发送消息（half消息）。
(2) 服务端响应消息写入结果。
(3) 根据发送结果执行本地事务（如果写入失败，此时half消息对业务不可见，本地逻辑不执行）。
(4) 根据本地事务状态执行Commit或者Rollback（Commit操作生成消息索引，消息对消费者可见）
7.1.2、事务补偿
(1) 对没有Commit/Rollback的事务消息（pending状态的消息），从服务端发起一次“回查”
(2) Producer收到回查消息，检查回查消息对应的本地事务的状态
(3) 根据本地事务状态，重新Commit或者Rollback
其中，补偿阶段用于解决消息Commit或者Rollback发生超时或者失败的情况。
7.1.3、事务消息状态
事务消息共有三种状态，提交状态、回滚状态、中间状态：
- TransactionStatus.CommitTransaction: 提交事务，它允许消费者消费此消息。
- TransactionStatus.RollbackTransaction: 回滚事务，它代表该消息将被删除，不允许被消费。
- TransactionStatus.Unknown: 中间状态，它代表需要检查消息队列来确定状态。
7.2、创建事务性生产者, 实现事务监听接口
使用 TransactionMQProducer类创建生产者，并指定唯一的 ProducerGroup，就可以设置自定义线程池来处理这些检查请求。执行本地事务后、需要根据执行结果对消息队列进行回复。
当发送半消息成功时，我们使用 executeLocalTransaction 方法来执行本地事务。它返回三个事务状态之一。checkLocalTranscation 方法用于检查本地事务状态，并回应消息队列的检查请求。它也是返回三个事务状态之一。
public class TranscationMQMessage {
private static String SERVER_ADDR = "192.168.1.4:9876";
@Test
/**
* 事务消息生产者
*/
public void transcationMQProducer() throws Exception {
// 1、创建事务生产者
TransactionMQProducer producer = new TransactionMQProducer("TranscationMQProducer");
producer.setNamesrvAddr(SERVER_ADDR);
// 2、指定事务监听者
producer.setTransactionListener(new TransactionListener() {
@Override
public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
// 执行本地事务
System.out.println("执行本地事务");
if (StringUtils.equals("TagA", msg.getTags())) {
return LocalTransactionState.COMMIT_MESSAGE;
} else if (StringUtils.equals("TagB", msg.getTags())) {
return LocalTransactionState.ROLLBACK_MESSAGE;
} else {
return LocalTransactionState.UNKNOW;
}
}
@Override
public LocalTransactionState checkLocalTransaction(MessageExt msg) {
// 检查本地事务状态
System.out.println("MQ检查消息Tag【" + msg.getTags() + "】的本地事务执行结果");
return LocalTransactionState.COMMIT_MESSAGE;
}
});
// 3、启动生产者
producer.start();
String[] tags = new String[]{"TagA", "TagB", "TagC"};
for (int i = 0; i < 3; i++) {
Message msg = new Message(
"TranscationTopic",
tags[i % tags.length],
("Transcation message " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
producer.sendMessageInTransaction(msg, null);
}
System.out.println("发送消息成功");
System.in.read();
}
}7.3、使用限制
- 事务消息不支持延时消息和批量消息。
- 为了避免单个消息被检查太多次而导致半队列消息累积，我们默认将单个消息的检查次数限制为 15 次，但是用户可以通过 Broker 配置文件的
transactionCheckMax参数来修改此限制。如果已经检查某条消息超过 N 次的话（ N =transactionCheckMax） 则 Broker 将丢弃此消息，并在默认情况下同时打印错误日志。用户可以通过重写AbstractTransactionCheckListener类来修改这个行为。 - 事务消息将在 Broker 配置文件中的参数 transactionMsgTimeout 这样的特定时间长度之后被检查。当发送事务消息时，用户还可以通过设置用户属性 CHECK_IMMUNITY_TIME_IN_SECONDS 来改变这个限制，该参数优先于
transactionMsgTimeout参数。 - 事务性消息可能不止一次被检查或消费。
- 提交给用户的目标主题消息可能会失败，目前这依日志的记录而定。它的高可用性通过 RocketMQ 本身的高可用性机制来保证，如果希望确保事务消息不丢失、并且事务完整性得到保证，建议使用同步的双重写入机制。
- 事务消息的生产者 ID 不能与其他类型消息的生产者 ID 共享。与其他类型的消息不同，事务消息允许反向查询、MQ服务器能通过它们的生产者 ID 查询到消费者。
8、SpringBoot整合RocketMQ
8.1、添加相关依赖
<dependency>
<groupId>org.apache.rocketmq</groupId>
<artifactId>rocketmq-spring-boot-starter</artifactId>
<version>${rocketmq-spring-boot-starter-version}</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.6</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>8.2、配置Application
rocketmq.name-server=192.168.137.1:9876
rocketmq.producer.group=unique_springboot_group8.3、编写消息生产者&消息消费者
- 消息生产者 RocketMQTemplate封装了大量直接操作的消息api，同时可以通过getProucer和createTransactionMQProducer来使用消息生产者
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = {Application.class})
public class SpringBootMQDemo {
@Autowired
RocketMQTemplate rocketMQTemplate;
@Test
public void spbMQProdducer() throws Exception {
for (int i = 0; i < 100; i++) {
rocketMQTemplate.convertAndSend("SPBRocketMQ", "Hello SpringBoot MQ Message" + i);
System.out.println("发送成功");
}
System.in.read();
}
}- 消息消费者
注解提供了大量针对消息的操作。
@Component
@RocketMQMessageListener(topic = "SPBRocketMQ", consumerGroup = "unique_springboot_consumer_gourp")
public class SpringBootMQConsumer implements RocketMQListener<String> {
@Override
public void onMessage(String s) {
System.out.printf("当前线程%s,消息内容%s %n", Thread.currentThread().getName(), s);
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
