1. Optimized formatting and indentation

2. Corrected some typos
3. Introduce of the Schedule Message

docs/cn/RocketMQ_Example.md

@@ -99,7 +99,6 @@ public class AsyncProducer {
 这种方式主要用在不特别关心发送结果的场景，例如日志发送。
 
 ```java
-
 public class OnewayProducer {
 	public static void main(String[] args) throws Exception{
     	// 实例化消息生产者Producer
@@ -121,12 +120,12 @@ public class OnewayProducer {
     	// 如果不再发送消息，关闭Producer实例。
     	producer.shutdown();
     }
+}
 ```
 
 ### 3、消费消息
 
 ```java
-
 public class Consumer {
 
 	public static void main(String[] args) throws InterruptedException, MQClientException {
@@ -141,7 +140,6 @@ public class Consumer {
         consumer.subscribe("TopicTest", "*");
     	// 注册回调实现类来处理从broker拉取回来的消息
         consumer.registerMessageListener(new MessageListenerConcurrently() {
- 
             @Override
             public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
                 System.out.printf("%s Receive New Messages: %s %n", Thread.currentThread().getName(), msgs);
@@ -149,17 +147,13 @@ public class Consumer {
                 return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
             }
         });
- 
         // 启动消费者实例
         consumer.start();
- 
         System.out.printf("Consumer Started.%n");
 	}
 }
-
 ```
 
-
 顺序消息样例
 ----------
 
@@ -167,12 +161,11 @@ public class Consumer {
 
 顺序消费的原理解析，在默认的情况下消息发送会采取Round Robin轮询方式把消息发送到不同的queue(分区队列)；而消费消息的时候从多个queue上拉取消息，这种情况发送和消费是不能保证顺序。但是如果控制发送的顺序消息只依次发送到同一个queue中，消费的时候只从这个queue上依次拉取，则就保证了顺序。当发送和消费参与的queue只有一个，则是全局有序；如果多个queue参与，则为分区有序，即相对每个queue，消息都是有序的。
 
-下面用订单进行示例。一个订单的顺序流程是：创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中，消费时，同一个OrderId获取到的肯定是同一个队列。
+下面用订单进行分区有序的示例。一个订单的顺序流程是：创建、付款、推送、完成。订单号相同的消息会被先后发送到同一个队列中，消费时，同一个OrderId获取到的肯定是同一个队列。
 
 ### 1、顺序消息生产
 
 ```java
-
 package org.apache.rocketmq.example.order2;
 
 import org.apache.rocketmq.client.producer.DefaultMQProducer;
@@ -320,13 +313,11 @@ public class Producer {
        return orderList;
    }
 }
-
 ```
 
 ### 2、顺序消费消息
 
 ```java
-
 import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
 import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
 import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
@@ -390,7 +381,6 @@ public class ConsumerInOrder {
        System.out.println("Consumer Started.");
    }
 }
-
 ```
 
 延时消息样例
@@ -462,6 +452,21 @@ public class ScheduledMessageProducer {
 
 您将会看到消息的消费比存储时间晚10秒。
 
+### 4、延时消息的使用场景
+1. 比如电商里，提交了一个订单就可以发送一个延时消息，1h后去检查这个订单的状态，如果还是未付款就取消订单释放库存。
+
+### 5、延时消息的使用限制
+
+```java
+// 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
+消息消费失败会进入延时消息队列，消息发送时间与设置的延时等级和重试次数有关，详见代码`SendMessageProcessor.java`
+
+
+
 批量消息样例
 ----------
 
@@ -558,41 +563,41 @@ consumer.subscribe("TOPIC", "TAGA || TAGB || TAGC");
 ```
 
 消费者将接收包含TAGA或TAGB或TAGC的消息。但是限制是一个消息只能有一个标签，这对于复杂的场景可能不起作用。在这种情况下，可以使用SQL表达式筛选消息。SQL特性可以通过发送消息时的属性来进行计算。在RocketMQ定义的语法下，可以实现一些简单的逻辑。下面是一个例子：
-
-\-\-\-\-\-\-\-\-\-\-\-\-  
-| message  |  
-|--------  | a > 5 AND b = 'abc'
-| a = 10   |  --------------------> Gotten  
+```
+------------
+| message  |
+|----------|  a > 5 AND b = 'abc'
+| a = 10   |  --------------------> Gotten
 | b = 'abc'|
-| c = true|  
-\-\-\-\-\-\-\-\-\-\-\-\-  
-\-\-\-\-\-\-\-\-\-\-\-\-  
-| message  |  
-|--------  | a > 5 AND b = 'abc'
-| a = 1  |  --------------------> Missed  
+| c = true |
+------------
+------------
+| message  |
+|----------|   a > 5 AND b = 'abc'
+| a = 1    |  --------------------> Missed
 | b = 'abc'|
-| c = true |  
-\-\-\-\-\-\-\-\-\-\-\-\-
-
+| c = true |
+------------
+```
 ### 1、基本语法
 
 RocketMQ只定义了一些基本语法来支持这个特性。你也可以很容易地扩展它。
 
-1. 数值比较，比如：**>，>=，<，<=，BETWEEN，=；**
-2. 字符比较，比如：**=，<>，IN；**
-3. **IS NULL** 或者 **IS NOT NULL；**
-4. 逻辑符号 **AND，OR，NOT；**
+- 数值比较，比如：**>，>=，<，<=，BETWEEN，=；**
+- 字符比较，比如：**=，<>，IN；**
+- **IS NULL** 或者 **IS NOT NULL；**
+- 逻辑符号 **AND，OR，NOT；**
 
 常量支持类型为：
 
-1. 数值，比如：**123，3.1415；**
-2. 字符，比如：**'abc'，必须用单引号包裹起来；**
-3. **NULL**，特殊的常量
-4. 布尔值，**TRUE** 或 **FALSE**
+- 数值，比如：**123，3.1415；**
+- 字符，比如：**'abc'，必须用单引号包裹起来；**
+- **NULL**，特殊的常量
+- 布尔值，**TRUE** 或 **FALSE**
 
 只有使用push模式的消费者才能用使用SQL92标准的sql语句，接口如下：
 ```
-publicvoidsubscribe(finalString topic, final MessageSelector messageSelector)
+public void subscribe(finalString topic, final MessageSelector messageSelector)
 ```
 
 ### 2、使用样例
@@ -646,7 +651,7 @@ consumer.start();
 
 #### 1. 创建事务性生产者
 
-使用 `TransactionMQProducer`类创建生产者客户，并指定唯一的 `ProducerGroup`，就可以设置自定义线程池来处理这些检查请求。执行本地事务后、需要根据执行结果对消息队列进行回复。回传的事务状态在请参考前一节。
+使用 `TransactionMQProducer`类创建生产者，并指定唯一的 `ProducerGroup`，就可以设置自定义线程池来处理这些检查请求。执行本地事务后、需要根据执行结果对消息队列进行回复。回传的事务状态在请参考前一节。
 
 ```java
 
@@ -726,14 +731,14 @@ public class TransactionListenerImpl implements TransactionListener {
 
 ```
 
-### 1、事务消息使用上的限制
+### 2、事务消息使用上的限制
 
 1. 事务消息不支持延时消息和批量消息。
 2. 为了避免单个消息被检查太多次而导致半队列消息累积，我们默认将单个消息的检查次数限制为 15 次，但是用户可以通过 Broker 配置文件的 `transactionCheckMax`参数来修改此限制。如果已经检查某条消息超过 N 次的话（ N = `transactionCheckMax` ） 则 Broker 将丢弃此消息，并在默认情况下同时打印错误日志。用户可以通过重写 `AbstractTransactionCheckListener` 类来修改这个行为。
 3. 事务消息将在 Broker 配置文件中的参数 transactionMsgTimeout 这样的特定时间长度之后被检查。当发送事务消息时，用户还可以通过设置用户属性 CHECK_IMMUNITY_TIME_IN_SECONDS 来改变这个限制，该参数优先于 `transactionMsgTimeout` 参数。
 4. 事务性消息可能不止一次被检查或消费。
 5. 提交给用户的目标主题消息可能会失败，目前这依日志的记录而定。它的高可用性通过 RocketMQ 本身的高可用性机制来保证，如果希望确保事务消息不丢失、并且事务完整性得到保证，建议使用同步的双重写入机制。
-6.  事务消息的生产者 ID 不能与其他类型消息的生产者 ID 共享。与其他类型的消息不同，事务消息允许反向查询、MQ服务器能通过它们的生产者 ID 查询客户。
+6. 事务消息的生产者 ID 不能与其他类型消息的生产者 ID 共享。与其他类型的消息不同，事务消息允许反向查询、MQ服务器能通过它们的生产者 ID 查询到消费者。
 
 Logappender样例
 -----------------
@@ -953,5 +958,4 @@ public class SimplePushConsumer {
        System.out.printf("Consumer startup OK%n");
    }
 }
-
 ```
\ No newline at end of file