RabbitMQ学习之工作队列

最新推荐文章于 2023-02-01 10:19:41 发布
最新推荐文章于 2023-02-01 10:19:41 发布
阅读量316 收藏 1
点赞数 1
分类专栏： 消息中间件 文章标签： rabbitmq 消息中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dyhdsg123456/article/details/90214362
版权

 

工作队列，又称任务队列，主要思想是避免立即执行资源密集型任务，并且必须等待完成。相反地，我们进行任务调度，我们将一个任务封装成一个消息，并将其发送到队列。工作进行在后台运行不断的从队列中取出任务然后执行。当你运行了多个工作进程时，这些任务队列中的任务将会被工作进程共享执行。

这个概念在 Web 应用程序中特别有用，在短时间 HTTP 请求内需要执行复杂的任务

 

发送端

package Rabbitmq.工作队列;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * Author: dyh
 * Date:   2019/5/14
 * Description:发送
 */
public class NewTask {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("localhost");
        //创建一个连接
        Connection connection = connectionFactory.newConnection();
        //创建一个通道
        Channel channel = connection.createChannel();
        //指定一个队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //发送消息
        for (int i = 0; i < 10; i++) {
            String message = "duyuanhao:" + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");
        }
        channel.close();
        connection.close();

    }
}

 接收端

package Rabbitmq.工作队列;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * Author: dyh
 * Date:   2019/5/14
 * Description:接收端
 */
public class Worker {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        ConnectionFactory factory = new ConnectionFactory();
        // 设置 RabbitMQ 的主机名
        factory.setHost("localhost");
        // 创建一个连接
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        final Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");

                System.out.println(" [x] Received '" + message + "'");
                try {
                    doWork(message);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        // acknowledgment is covered below
        boolean autoAck = true;
        channel.basicConsume(QUEUE_NAME, autoAck, consumer);
    }


    private static void doWork(String task) throws InterruptedException {
        String[] taskArr = task.split(":");
        TimeUnit.SECONDS.sleep(Long.valueOf(taskArr[1]));
    }
}

开启2个接收端 一个发送端

开启3个接收端

我们发现，通过增加更多的工作程序就可以进行并行工作，并且接受的消息平均分配。注意的是，这种分配过程是一次性分配，并非一个一个分配。

默认情况下，RabbitMQ 将会发送的每一条消息按照顺序给下一个消费者。平均每一个消费者将获得相同数量的消息。这种分发消息的方式叫做轮询调度。

 

消息应答（Message acknowledgment）

执行一个任务可能需要几秒钟。你可能会想，如果一个消费者开始一个长期的任务，并且只有部分地完成它，会发生什么事情？使用我们当前的代码，一旦 RabbitMQ 向客户发送消息，它立即将其从内存中删除。在这种情况下，如果你杀死正在执行任务的某个工作进程，我们会丢失它正在处理的信息。我们还会丢失所有发送给该特定工作进程但尚未处理的消息。

但是，我们不想失去任何消息。如果某个工作进程被杀死时，我们希望把这个任务交给另一个工作进程。

为了确保消息永远不会丢失，RabbitMQ 支持消息应答。从消费者发送一个确认信息告诉 RabbitMQ 已经收到消息并已经被接收和处理，然后RabbitMQ 可以自由删除它。

如果消费者被杀死而没有发送应答，RabbitMQ 会认为该信息没有被完全的处理，然后将会重新转发给别的消费者。如果同时有其他消费者在线，则会迅速将其重新提供给另一个消费者。这样就可以确保没有消息丢失，即使工作进程偶尔也会死亡。

默认情况下，消息应答是开启的。在前面的例子中，我们通过 autoAck = true 标志明确地将它们关闭。现在是一旦完成任务，将此标志设置为false ，并向工作进程发送正确的确认。

 

发送端

package Rabbitmq.消息应答;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * Author: dyh
 * Date:   2019/5/14
 * Description:
 */
public class AckNewTask {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        ConnectionFactory factory = new ConnectionFactory();
        // 设置 RabbitMQ 的主机名
        factory.setHost("localhost");
        // 创建一个连接
        Connection connection = factory.newConnection();
        // 创建一个通道
        Channel channel = connection.createChannel();
        // 指定一个队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        // 发送消息
        for (int i = 0; i < 10; i++) {
            String message = "duyuanhao:" + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");
        }
        // 关闭频道和连接
        channel.close();
        connection.close();
    }
}

接收端

package Rabbitmq.消息应答;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * Author: dyh
 * Date:   2019/5/14
 * Description:
 */
public class AckWorker {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        ConnectionFactory factory = new ConnectionFactory();
        // 设置 RabbitMQ 的主机名
        factory.setHost("localhost");
        // 创建一个连接
        Connection connection = factory.newConnection();
        // 创建一个通道
        final Channel channel = connection.createChannel();
        // 指定一个队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        final Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                String message = new String(body, "UTF-8");

                System.out.println(" [x] Received '" + message + "'");
                try {
                    doWork(message);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally{
                    // 每次处理完成一个消息后，手动发送一次应答。
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        };
        //关闭自动应答
        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME, autoAck, consumer);
    }

    private static void doWork(String task) throws InterruptedException {
        String[] taskArr = task.split(":");
        TimeUnit.SECONDS.sleep(Long.valueOf(taskArr[1]));
    }

}

开启三个接收端 一个发送端 然后停止其中一个接收端 

可以看到 2被再次发送

 

消息持久化（Message durability）

我们已经学会了如何确保即使消费者死了，任务也不会丢失。但是如果 RabbitMQ 服务器停止，我们的任务仍然会丢失。

当 RabbitMQ 退出或崩溃时，将会丢失所有的队列和信息，除非你告诉它不要丢失。需要两件事来确保消息不丢失：我们需要分别将队列和消息标记为持久化。

发送端

package Rabbitmq.持久化;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * Author: dyh
 * Date:   2019/5/14
 * Description:发送
 */
public class NewTask {
    private final static String QUEUE_NAME = "hello_durable";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();

        connectionFactory.setHost("localhost");
        //创建一个连接
        Connection connection = connectionFactory.newConnection();
        //创建一个通道
        Channel channel = connection.createChannel();
        //指定一个队列
        //声明为持久化
        boolean durable = true;
        channel.queueDeclare(QUEUE_NAME, durable, false, false, null);
        //发送消息
        for (int i = 0; i < 10; i++) {
            String message = "duyuanhao:" + i;
            channel.basicPublish("", QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");
        }
        channel.close();
        connection.close();

    }
}

接收端

package Rabbitmq.持久化;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * Author: dyh
 * Date:   2019/5/14
 * Description:接收端
 */
public class Worker {
    private final static String QUEUE_NAME = "hello_durable";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        ConnectionFactory factory = new ConnectionFactory();
        // 设置 RabbitMQ 的主机名
        factory.setHost("localhost");
        // 创建一个连接
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //声明为持久化
        boolean durable = true;
        channel.queueDeclare(QUEUE_NAME,durable,false,false,null);

        final Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");

                System.out.println(" [x] Received '" + message + "'");
                try {
                    doWork(message);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        // acknowledgment is covered below
        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME, autoAck, consumer);
    }


    private static void doWork(String task) throws InterruptedException {
        String[] taskArr = task.split(":");
        TimeUnit.SECONDS.sleep(Long.valueOf(taskArr[1]));
    }
}

 此时开启一个发送端 查看控制台

 

然后关闭rabbitmq服务再重启 如下 

 

 开启接收端依然能接收到10条消息 说明持久化成功

 

公平转发（Fair dispatch）

您可能已经注意到，调度仍然无法正常工作。例如在两个工作线程的情况下，一个工作线程将不断忙碌，另一个工作人员几乎不会做任何工作。那么，RabbitMQ 不知道什么情况，还会平均分配消息。

这是因为当消息进入队列时，RabbitMQ 只会分派消息。它不看消费者的未确认消息的数量。它只是盲目地向第 n 个消费者发送每个第 n 个消息。

为了解决这样的问题，我们可以使用 basicQos 方法，并将传递参数为 prefetchCount = 1。

这样告诉 RabbitMQ 不要一次给一个工作线程多个消息。换句话说，在处理并确认前一个消息之前，不要向工作线程发送新消息。相反，它将发送到下一个还不忙的工作线程。

 

发送端

package Rabbitmq.公平转发;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * Author: dyh
 * Date:   2019/5/14
 * Description:
 */
public class FairNewTask {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        ConnectionFactory factory = new ConnectionFactory();
        // 设置 RabbitMQ 的主机名
        factory.setHost("localhost");
        // 创建一个连接
        Connection connection = factory.newConnection();
        // 创建一个通道
        Channel channel = connection.createChannel();
        // 指定一个队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
//        // 公平转发
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);
        // 发送消息
        for (int i = 0;i < 25; i++) {
            String message = "duyuanhao:" + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");
        }
        // 关闭频道和连接
        channel.close();
        connection.close();
    }

}

 开启公平转发

然后创建2个接收端 一个睡眠1秒 1个睡眠2秒

 

package Rabbitmq.公平转发;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * Author: dyh
 * Date:   2019/5/14
 * Description:
 */
public class Worker2 {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        ConnectionFactory factory = new ConnectionFactory();
        // 设置 RabbitMQ 的主机名
        factory.setHost("localhost");
        // 创建一个连接
        Connection connection = factory.newConnection();
        // 创建一个通道
        final Channel channel = connection.createChannel();
        // 指定一个队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);
        final Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                String message = new String(body, "UTF-8");

                System.out.println(" [x] Received '" + message + "'");
                try {
                    Thread.sleep(2000);//休息2秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 每次处理完成一个消息后，手动发送一次应答。
                    channel.basicAck(envelope.getDeliveryTag(), false);

            }
        };
        //关闭自动应答
        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME, autoAck, consumer);
    }



}

package Rabbitmq.公平转发;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * Author: dyh
 * Date:   2019/5/14
 * Description:
 */
public class Worker {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        ConnectionFactory factory = new ConnectionFactory();
        // 设置 RabbitMQ 的主机名
        factory.setHost("localhost");
        // 创建一个连接
        Connection connection = factory.newConnection();
        // 创建一个通道
        final Channel channel = connection.createChannel();
        // 指定一个队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);
        final Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                String message = new String(body, "UTF-8");

                System.out.println(" [x] Received '" + message + "'");
                try {
                    Thread.sleep(1000);//休息1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                    channel.basicAck(envelope.getDeliveryTag(), false);

            }
        };
        //关闭自动应答
        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME, autoAck, consumer);
    }



}

 然后开启2个接收端和1个发送端

可以看出 worker1 明细消费了更多消息 

完整代码

https://github.com/dyhdsg123456/Mq_Study

dyhdsg123456
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BGDGFDGHDHDSGHSG
02-07
SGSRSGSRGRSGRSGRSDFGSG
RabbitMQ 实战教程（二） 工作队列
咖啡的博客
03-20 140
工作队列，又称任务队列，主要思想是避免立即执行资源密集型任务，并且必须等待完成。相反地，我们进行任务调度，我们将一个任务封装成一个消息，并将其发送到队列。工作进行在后台运行不断的从队列中取出任务然后执行。当你运行了多个工作进程时，这些任务队列中的任务将会被工作进程共享执行。 这个概念在 Web 应用程序中特别有用，在短时间 HTTP 请求内需要执行复杂的任务。 准备工作 现在，假装我们很...
hdsg:你已经选择了吗
05-10
hdsg Hast du schongewählt？ 一种用于检查人们是否已经通过邮寄学生议会选举进行投票的软件。 在哪里使用此软件 不要在连接到Internet的计算机上运行带有实时数据的软件。 它不是为此目的而构建的，因此不适合保护其处理的数据免受攻击。 仅在运行该软件的计算机上并且运行该软件的客户端位于与外界隔离的本地网络中，才能运行该软件。 如何使用此软件 设置mariadb数据库 修改config.py的配置。 特别是选择一个不同的随机SECRET_KEY值。 使用适合此目的的某种服务器（例如，gunicorn）运行此python应用程序。 使用脚本setup.py导入具有密码的用户列表 使用脚本setup.py导入您的选民名单 使用Web浏览器从客户端连接到正在运行的服务器，使用导入的用户名/密码组合登录，并开始扫描和标记ID 示范模式 您可以使用demo作为用户名
DAEFGHDSGFEVRHQKLVFFAEDVGSNKGAIIGLMVGGVV，144409-98-3
salepeptide的博客
02-01 59
Amyloid β-peptide (1-40) (rat) 是蛋白水解切割淀粉样蛋白前体蛋白的易聚集产物，并且是在阿尔茨海默病脑中观察到的老年斑的主要成分。编号: 128097中文名称: β淀粉肽(1-40)(鼠)、β-Amyloid(1-40), rat中文同义词: β淀粉样肽(1-40)(鼠)英文名: β-Amyloid(1-40), ratCAS号: 144409-98-3单字母: H2N-DAEFGHDSGFEVRHQKLVFFAEDVGSNKGAIIGLMVGGVV-OH三字母: H2N-Asp
python实现图像检索的三种(直方图/OpenCV/哈希法)
12-26
简介： 本文介绍了图像检索的三种实现方式，均用python完成，其中前两种基于直方图比较，哈希法基于像素分布。 检索方式是：提前导入图片库作为检索范围，给出待检索的图片，将其与图片库中的图片进行比较，得出所有相似度后进行排序，从而检索结果为相似度由高到低的图片。由于工程中还包含Qt界面类、触发函数等其他部分，在该文档中只给出关键函数的代码。 开发系统：MacOS 实现方式：Qt + Python 方法一：自定义的直方图比较算法 a) 基本思路 遍历图片像素点，提取R\G\B值并进行对应的计数，得到原始直方图，但由于0-255的范围太大，因此每一个像素值的统计量均偏小，因此分别将R\G
基于rabbitMQ实现的消息队列（MQ）
10-09
消息队列（MQ）是一种中间件技术，用于在分布式系统中解耦生产者和消费者，通过缓存消息来提高系统的可...通过学习和使用提供的源代码，开发者可以更好地理解如何在Java项目中集成和利用RabbitMQ实现消息队列的功能。
利用Python学习RabbitMQ消息队列
12-23
RabbitMQ可以当做一个消息代理，它的核心原理非常简单：即接收和发送消息，可以把它想象成一个邮局：我们把信件放入邮箱，邮递员就会把信件投递到你的收件人处，RabbitMQ就是一个邮箱、邮局、投递员功能综合体，整个...
消息队列RabbitMQ学习-1
01-20
消息队列RabbitMQ学习 为什么学习RabbitMQ 每一种技术的出现，都是为了解决业务需求而产生的。通常的背景是，在某种业务场景下，出现了某种问题，怎么解决这种问题，一个新的技术产生了。下面举个单体架构的例子来...
rabbitmq学习笔记和软件和插件
05-05
**RabbitMQ学习笔记与软件插件详解** RabbitMQ是一种广泛应用的消息中间件，它基于AMQP（Advanced Message Queuing Protocol）协议，提供可靠的消息传递服务。在分布式系统中，RabbitMQ扮演着数据交换中心的角色，...
解读HDS GAD双活数据中心方案.docx
11-01
GAD不是“封装”解决方案，也不是“外部虚拟化”解决方案，而是全局动态存储虚拟化技术（包括双活镜像） 。 其基于存储实现双活，它不仅实现了IT系统管理的大幅简化与自动化，还具有高可用性特征，可确保任务关键型数据和应用程序的永续运行。
Windows Installer CleanUp Utility_v4.71.1015.0
02-06
用于删除一些难以卸载的或者难以找到的注册表信息等等
svn对项目权限进行管理
数据库天地
07-31 1517
昨日一篇有关svn的文章，对Repository理解有偏差，今天重新整理发表。 一 创建Repositories 每一个Repositorty是一个仓库，这个仓库里可以放入多个项目。可以对每个项目分别管理，也可以对整个仓库管理。 二 创建Users 三 创建Group 四 分配权限(对于仓库) 我们可以对整个Repositories分配权限或者Reposit...
LoadRunner测试一个简单的AJAX例子
热门推荐
软件质量优化
02-05 1万+
  测试的例子：http://www.degraeve.com/reference/simple-ajax-example.php  如果用WEB(HTTP/HTML)协议来录制，则AJAX行为会被录制成web_submit_data函数：Action(){        web_add_cookie("__utma=251078419.12133289
Docker在测试领域的应用
软件质量优化
11-22 8682
参考资料：《The Docker Book》- Testing with Docker《Docker从入门到实践》– 标准化开发测试和生产环境http://wiki.jikexueyuan.com/project/docker-technology-and-combat/environment.html构建基于 Docker + Jenkins + Sahi 的 Web UI 自动化测试环境htt
WINDOWS中cmd的切换目录cd命令失效
hdsghtj的博客
11-11 853
WINDOWS中cmd的切换目录cd命令失效
maven中引用JDK中的tools jar
hdsghtj的博客
11-14 7644
maven中引用JDK中的tools jar
测试人员该学习哪些Linux知识
hdsghtj的博客
02-16 1500
测试人员该学习哪些Linux知识
jQuery中find和filter的区别
web开发自学
02-13 191
这是jQuery里常用的2个方法。 他们2者功能是完全不同的，而初学者往往会被误导。 现在有一个页面，里面HTML代码为;&lt;div&gt; &lt;pclass="rain"&gt;测试1&lt;/p&gt;&lt;/div&gt; &lt;divclass="rain"&gt;&lt;p&gt;测试2&lt;/p&gt;&lt;/
Mybatis中传参包There is no getter for property named 'XXX' in 'c
hdsghtj的博客
11-06 907
Mybatis中传参包There is no getter for property named 'XXX' in 'c
rabbitmq的私信队列
最新发布
08-24
私信队列是RabbitMQ中的一种特殊队列，用于处理无法被消费者处理或处理失败的消息。当消息在被消费者拒绝后，可以通过私信队列重新发送给特定的消费者进行处理。私信队列的实现方式是通过死信机制来实现的。 在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值