清空/重置队列

最新推荐文章于 2023-04-24 09:36:20 发布
最新推荐文章于 2023-04-24 09:36:20 发布
阅读量379 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 游戏 javascript 大数据 ViewUI
原文链接：http://www.cnblogs.com/mysic/p/6148352.html

（1）首先关闭rabbitmq: rabbitmqctl stop_app

（2）还原： rabbitmqctl reset

（3）启动： rabbitmqctl start_app

（4）添加用户： rabbitmqctl add_user root root

（5）设置权限：rabbitmqctl set_permissions -p / root ".*" ".*" ".*"

（6）查看用户： rabbitmqctl list_users

-----------------------------------------------以上为早期的从网上找的方法，如果仅是清空某个队列则用

rabbitmqctl  purge_queue 　QueueName

这样就可以清空指定的队列

转载于:https://www.cnblogs.com/mysic/p/6148352.html

清空链队列 c语言,【C语言实现】链队列(内有完整代码)
weixin_42298969的博客
05-20 1886
简书内代码已上传GitHub：点击我 去GitHub查看代码如有错误，还请大佬们一定留言指出！！建议先阅读 顺序队列 后再食用单链队列不在身边的你，也链接着我一. 链队列相信只要是开始了解链队列的小伙伴已经对线性表了如指掌了，上一篇 写到了顺序存储方式的队列需要用循环队列来实现，但实现难度和扩展性都比链队列差了多...我...自己认为...单链队列真的...没必要有头节点，直接第一个节点就储存元素...
链队列的基本操作（初始化、销毁、清空等）
m0_56287454的博客
10-29 1万+
（1）实验目的 通过该实验，使学生理解链队列的构造特点并灵活应用，掌握链队基本操作的编程实现，认识栈是在一端进行插入，在另一端进行删除集中操作的线性结构，掌握队列的“先入先出”操作特点，知道判断队列空和满的条件，进一步熟悉C语言中指针操作。 （2）实验内容 用链式存储结构，实现教材定义的队列的基本操作。 （3）参考界面 菜单中包括以下功能： 1.初始化队列，2.销毁队列，3.清空队列，4. 队列判空，5.求队列长度，6.获取队头元素，7.插入一个 元素...
具有Reset功能的多线程同步队列 - 2
zgqtxwd的专栏
04-27 297
<!--google_ad_client = "pub-2947489232296736";/* 728x15, 创建于 08-4-23MSDN */google_ad_slot = "3624277373";google_ad_width = 728;google_ad_height = 15;//--><script type="text/javascript"
数据结构中循环队列的清空、销毁、求队长、遍历、取首元素等操作及运用
wys_NO1的博客
11-03 1万+
数据结构中队列有好几种形式，本文写的是循环队列，以下为原创代码。创建c++工程： 头文件一：基本定义和头文件 #include"stdlib.h" #include"stdio.h" #define MAXQSIZE 100 #define OK 1 #define ERROR -1 #define TURE 1 #define FALSE 0 #define O
队列的创建，销毁，清空，入队，出队，判空，判满等操作
08-17
本程序实现了队列的相关操作，包括 创建，销毁，清空，入队，出队，判空，判满等操作，实现过程清晰简洁。是很好的学习资源
watchdog中handlerchecker实现了Runnable接口并重写run方法，其中的run()作用是什么 @Override public void run() { final int size = mMonitors.size(); //遍历队列中的所有对象 for (int i = 0 ; i < size ; i++) { synchronized (mLock) {//尝试获取锁 //重置当前检测对象 mCurrentMonitor = mMonitors.get(i); } //调用monitor()方法 //所有元素都是实现了watchdog.monitor接口的对象 mCurrentMonitor.monitor(); //避免监控过程本身引发问题，该方法设计为在无锁状态下执行 } synchronized (mLock) { //能获取到锁就说明没有发生堵塞 mCompleted = true;//重置状态为true mCurrentMonitor = null;//置检测对象为空 } }
最新发布
08-02
**状态标记**：在完成所有监控检查后，标记当前HandlerChecker为已完成（mCompleted=true），并清空当前监控对象。 为什么需要这样设计？ - 将监控检查（monitor()调用）放在同步块外部，是为了防止某个Monitor...
那在@Override public void run() { final int size = mMonitors.size(); //遍历队列中的所有对象 for (int i = 0 ; i < size ; i++) { synchronized (mLock) {//尝试获取锁 //重置当前检测对象 mCurrentMonitor = mMonitors.get(i); } //调用monitor()方法 //所有元素都是实现了watchdog.monitor接口的对象 mCurrentMonitor.monitor(); } synchronized (mLock) { //能获取到锁就说明 mCompleted = true; mCurrentMonitor = null; } }代码中，哪里表示获取到锁了呢
07-31
// 遍历队列中的所有对象 for (int i = 0 ; i ; i++) { synchronized (mLock) { // 锁获取点 1 // 能执行到此处表示已成功获取 mLock mCurrentMonitor = mMonitors.get(i); // 安全更新当前监控对象 } // ...
unsigned int mqtt_parser(CircularQueue *q, uint8_t *packet_buff) { // 静态变量：跨函数调用保持状态 static uint8_t state = 0; // 解析状态机当前状态 static uint32_t total_length = 0; // 待解析报文的总长度（固定报头+剩余长度+负载） static uint8_t remaining_length_bytes = 0; // 剩余长度字段占用的字节数 static uint8_t time_out = 0; // 超时计数器（连续未完整解析的次数） // 局部变量 uint8_t packet_type; // MQTT报文类型（存储在固定报头的第1个字节） uint8_t byte; // 临时存储从队列读取的字节 uint8_t multiplier; // 剩余长度解码时的乘数（1, 128, 128^2, 128^3） uint8_t remaining_length; // 解析出的剩余长度值（不包含固定报头和剩余长度字段本身） uint32_t current_offset; // 当前正在解析的字节在队列中的偏移量 uint32_t i; // 循环计数器 while (1) { // 检查队列中是否有足够的基础数据（至少需要2字节才能开始解析） if (Queue_Length(q) < 2) { return 0; // 数据不足，等待更多数据 } // 状态机处理 switch (state) { case 0: // 解析固定报头和剩余长度 // 读取固定报头的第1个字节（包含报文类型和标志位） Queue_PeekAt(q, 0, &packet_type); LOG_PRINTF("[MQTT Parser] Processing packet type: 0x%02X\n", packet_type); // 验证报文类型是否合法 if (!validate_packet_header(packet_type)) { LOG_PRINTF("[MQTT Parser] Invalid packet header: 0x%02X\n", packet_type); Queue_MoveReadIndex(q, 1); // 丢弃无效字节 state = 0; time_out = 0; return 0; } // 初始化剩余长度解析相关变量 multiplier = 1; // 初始乘数为1（128^0） total_length = 0; // 重置总长度 remaining_length_bytes = 0; // 重置剩余长度字节计数器 remaining_length = 0; // 重置剩余长度值 // 解析剩余长度字段（可能占用1~4字节） do { // 检查队列中是否有足够数据读取下一个剩余长度字节 if (Queue_Length(q) < (1 + remaining_length_bytes + 1)) { return 0; // 数据不足，等待更多数据 } // 计算当前剩余长度字节的偏移量（固定报头1字节 + 已解析的剩余长度字节数） current_offset = 1 + remaining_length_bytes; Queue_PeekAt(q, current_offset, &byte); // 读取当前剩余长度字节 // 解码剩余长度值（每个字节的低7位是有效数据，最高位是继续标志） remaining_length += (byte & 0x7F) * multiplier; multiplier *= 128; // 乘数递增（1, 128, 128^2, 128^3） remaining_length_bytes++; // 剩余长度字节计数器递增 // 协议合规性检查：剩余长度最多占用4字节 if (remaining_length_bytes >= 4 && (byte & 0x80)) { LOG_PRINTF("[MQTT Parser] Invalid remaining length (exceeds 4 bytes)\n"); Queue_MoveReadIndex(q, 1 + remaining_length_bytes); // 丢弃错误报文 state = 0; time_out = 0; return 0; } } while (byte & 0x80); // 继续循环直到遇到剩余长度的最后一个字节（最高位为0） // 计算完整报文长度：固定报头（1字节） + 剩余长度字节数 + 剩余长度值 total_length = 1 + remaining_length_bytes + remaining_length; LOG_PRINTF("[MQTT Parser] Packet length: %u bytes\n", total_length); // 切换到状态1，准备读取完整报文 state = 1; break; case 1: // 读取完整报文 // 检查队列中是否有完整的报文数据 if (Queue_Length(q) < total_length) { // 超时处理：连续MAX_TIMEOUT_COUNT次未能解析出完整报文，则丢弃1字节（防止队列被无效数据阻塞） time_out++; if (time_out >= MAX_TIMEOUT_COUNT) { LOG_PRINTF("[MQTT Parser] Timeout, discard 1 byte\n"); Queue_MoveReadIndex(q, 1); // 移动读指针，丢弃1字节 state = 0; // 重置状态机 time_out = 0; // 重置超时计数器 return 0; } return 0; // 数据不足，等待更多数据 } // 批量读取报文数据到输出缓冲区 for (i = 0; i < total_length; i++) { Queue_PeekAt(q, i, &packet_buff[i]); LOG_PRINTF("%02X ", packet_buff[i]); // 调试输出：打印报文字节 } printf("\n"); // 移动队列读指针，丢弃已读取的报文数据 Queue_MoveReadIndex(q, total_length); // 重置状态机和超时计数器 state = 0; time_out = 0; // 返回解析成功的报文长度 return total_length; default: // 未知状态，重置状态机 LOG_PRINTF("[MQTT Parser] Unknown state, resetting\n"); state = 0; time_out = 0; return 0; } } } 现在我将超时处理放到CASE1中，并且我想增加超时移除以读取的数据
07-13
如果超时，则丢弃当前队列中所有可用的数据（最多total_length个字节，因为报文预期长度是total_length，我们想跳过这个报文），然后重置状态。 步骤4：在default状态中，我们也要重置超时计数器吗？可以保留原有...
/** * @brief MQTT协议报文解析器 * @param q 循环队列指针，存储待解析的MQTT报文数据 * @param packet_buff 输出缓冲区，用于存储解析出的完整MQTT报文 * @return 解析成功的报文长度（字节数），返回0表示解析失败或数据不足 */ unsigned int mqtt_parser(CircularQueue *q, uint8_t *packet_buff) { // 静态变量：跨函数调用保持状态 static uint8_t state = 0; // 解析状态机当前状态 static uint32_t total_length = 0; // 待解析报文的总长度（固定报头+剩余长度+负载） static uint8_t remaining_length_bytes = 0; // 剩余长度字段占用的字节数 static uint8_t time_out = 0; // 超时计数器（连续未完整解析的次数） // 局部变量 uint8_t packet_type; // MQTT报文类型（存储在固定报头的第1个字节） uint8_t byte; // 临时存储从队列读取的字节 uint8_t multiplier; // 剩余长度解码时的乘数（1, 128, 128^2, 128^3） uint8_t remaining_length; // 解析出的剩余长度值（不包含固定报头和剩余长度字段本身） uint32_t current_offset; // 当前正在解析的字节在队列中的偏移量 uint32_t i; // 循环计数器 while (1) { // 检查队列中是否有足够的基础数据（至少需要2字节才能开始解析） if (Queue_Length(q) < 2) { return 0; // 数据不足，等待更多数据 } // 状态机处理 switch (state) { case 0: // 解析固定报头和剩余长度 // 读取固定报头的第1个字节（包含报文类型和标志位） Queue_PeekAt(q, 0, &packet_type); LOG_PRINTF("[MQTT Parser] Processing packet type: 0x%02X\n", packet_type); // 验证报文类型是否合法 if (!validate_packet_header(packet_type)) { LOG_PRINTF("[MQTT Parser] Invalid packet header: 0x%02X\n", packet_type); Queue_MoveReadIndex(q, 1); // 丢弃无效字节 state = 0; time_out = 0; return 0; } // 初始化剩余长度解析相关变量 multiplier = 1; // 初始乘数为1（128^0） total_length = 0; // 重置总长度 remaining_length_bytes = 0; // 重置剩余长度字节计数器 remaining_length = 0; // 重置剩余长度值 // 解析剩余长度字段（可能占用1~4字节） do { // 检查队列中是否有足够数据读取下一个剩余长度字节 if (Queue_Length(q) < (1 + remaining_length_bytes + 1)) { return 0; // 数据不足，等待更多数据 } // 计算当前剩余长度字节的偏移量（固定报头1字节 + 已解析的剩余长度字节数） current_offset = 1 + remaining_length_bytes; Queue_PeekAt(q, current_offset, &byte); // 读取当前剩余长度字节 // 解码剩余长度值（每个字节的低7位是有效数据，最高位是继续标志） remaining_length += (byte & 0x7F) * multiplier; multiplier *= 128; // 乘数递增（1, 128, 128^2, 128^3） remaining_length_bytes++; // 剩余长度字节计数器递增 // 协议合规性检查：剩余长度最多占用4字节 if (remaining_length_bytes >= 4 && (byte & 0x80)) { LOG_PRINTF("[MQTT Parser] Invalid remaining length (exceeds 4 bytes)\n"); Queue_MoveReadIndex(q, 1 + remaining_length_bytes); // 丢弃错误报文 state = 0; time_out = 0; return 0; } } while (byte & 0x80); // 继续循环直到遇到剩余长度的最后一个字节（最高位为0） // 计算完整报文长度：固定报头（1字节） + 剩余长度字节数 + 剩余长度值 total_length = 1 + remaining_length_bytes + remaining_length; LOG_PRINTF("[MQTT Parser] Packet length: %u bytes\n", total_length); state = 1; break; case 1: // 检查数据是否完整、超时处理 // 检查队列中是否有完整的报文数据 if (Queue_Length(q) < total_length) { // 超时处理：给一个比较长的超时时间，如果队列中的数据量都还达不到报文长度，则丢弃所有数据 time_out++; if (time_out >= MAX_TIMEOUT_COUNT) { if(Queue_Length(q) < total_length) { LOG_PRINTF("[MQTT Parser] Timeout, discard all byte\n"); Queue_MoveReadIndex(q, Queue_Length(q)); // 移动读指针，丢弃当前队列中所有数据 state = 0; // 重置状态机 time_out = 0; // 重置超时计数器 return 0; } } return 0; // 数据不足，等待更多数据 } else // 数据完整,准备读取完整数据 { state = 2; break; } case 2: // 读取完整报文 // 批量读取报文数据到输出缓冲区 for (i = 0; i < total_length; i++) { Queue_PeekAt(q, i, &packet_buff[i]); LOG_PRINTF("%02X ", packet_buff[i]); // 调试输出：打印报文字节 } printf("\n"); // 移动队列读指针，丢弃已读取的报文数据 Queue_MoveReadIndex(q, total_length); // 重置状态机和超时计数器 state = 0; time_out = 0; // 返回解析成功的报文长度 return total_length; default: // 未知状态，重置状态机 LOG_PRINTF("[MQTT Parser] Unknown state, resetting\n"); state = 0; time_out = 0; return 0; } } }状态0：初始状态，检查数据类型，获取报文长度 状态1：等待剩余长度解析完成，并检查报文合法性 状态2：等待完整报文数据 在状态0中，我们主要检查报文头（固定头第一个字节）的合法性，并解析剩余长度（第二个字节开始的可变长度整数）。同时，我们需要处理超时情况，如果在一定时间内没有解析出剩余长度，则丢弃已读取的报头部分（包括固定头第一个字节和已经读到的剩余长度字节）并回到初始状态。增加一个变量记录转到状态1时队列长度，用来判断有没有数据加入。 在状态1中，我们已经解析出了剩余长度，因此知道了整个报文的长度（1字节固定头+剩余长度字节数+剩余长度表示的数据长度）。此时，我们判断队列中数据是否足够组成一个完整报文。如果不够，则等待，并启动超时计时。超时分为两种情况： a) 在等待过程中有新数据加入，（有可能是新报文）但是直到超时仍然不够，所以只能丢弃报头部分（1+剩余长度字节数）并回到状态0。 b) 在等待过程中没有新数据加入（即队列数据量一直不变），则清空队列并回到状态0。 当数据足够时，进入状态2，从队列中取出完整报文。 注意：上述代码中，状态0和状态1、2是连续的，在状态0解析完报头后，直接进入状态1，然后如果状态1中数据足够，又直接进入状态2，所以用switch case时，状态0和状态1后面没有break，会继续执行后面的状态。这样设计是为了在一次调用中尽可能完成报文的提取。 按照要求更改这个代码
07-13
没有新数据加入（队列长度未变）-> 清空队列并回到state0。 state2: 从队列中取出整个报文（长度为之前计算的整个报文长度），然后重置状态机到state0。 注意：在state0中，我们可能只读取了部分剩余长度字节...
链式队列的基本操作（入队、出队、遍历队列、清空队列）
Kevinnsm的博客
03-30 9873
链式队列是一种特殊的链表，只能在尾部添加，在头部删除，类似于排队问题，先入先出 代码如下 #include<stdio.h> #include<malloc.h> #include<stdlib.h> #define ERROR 0 typedef int ElemType; typedef struct Queue{ struct Queue*next; ...
c++,链队列的基本操作(创建,销毁,查找,删除,插入等)
06-13
c++,链队列的基本操作(创建,销毁,查找,删除,插入等)
Qt5.12实战之线程信号与线程资源清理操作
04-24 415
在子线程的代码中要添加pthread_testcancel();当pthread_cleanup_pop(0) 传入的参数为0时不做任何操作。5.阻塞主线程,直到子线程执行完成。9.通过入栈与出栈清理线程占用资源。1.实现线程信号处理函数。2.注册线程信号处理函数。7.检测指定线程是否存在。8.取消正在运行的线程。支持取消的线程函数实现。
【C语言数据结构】链队列
W1024201的博客
03-25 3301
目录 前言 一、链队列 1.链队列头文件及函数声明 2.初始化 3.结点申请 4.结点释放 5.入队 6.获取队头元素 5.出栈 6.清空与销毁 1.清空 2.销毁 8.循环队列源文件及整体函数实现 总结 前言 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 链队列，实际本身是一个链表，但是因为链表...
队列文档之循环队列
二木成林
05-09 8686
循环队列就是将顺序队列臆造成一个环状的空间（实际上不是，只是把它看成是环状的），即把存储队列元素的顺序表从逻辑上视为一个环。
LimitQueue固定长度的队列
热门推荐
阿飞的博客
06-03 1万+
在开发过程中，有时会有这样的需求，一个固定长度的集合里，当收到新的数据时自动丢掉最旧的数据这样的队列结构。其实实现并不难，即一个队列结构的集合，在推送新数据时判断一下，当集合大小已经达到限制长度时自动丢掉最旧的数据。import java.util.LinkedList; public class LimitQueue&lt;E&gt;{ private int limit; //...
动态链式队列
pi9nc的专栏
07-21 2735
动态链式队列详解及完整实例演示 分类： 数据结构 C语言相关 2013-07-20 18:09 80人阅读 评论(0) 收藏 举报 队列 队列(Queue)是只允许在一端(队尾rear)进行插入，而在另一端(队头front)进行删除的运算受限的线性表。它是一种可以实现“先进先出”(FIFO)的存储结构。队列在具体应用中通常用链表或者数组来实现，因此我们也常常将队列
循环队列
qq_39475906的博客
05-09 1832
循环队列 特性：先进先出，浪费一个数据单元，用来判断是否为满 原理 代码实现 class QueueLink{ int elem[]; /** * 队头 */ int front; /** * 队尾 */ int rear; /** * 当前循环内部有效循环个数 */ ...
Vue.nextTick（）的使用
caigoutu的博客
06-18 516
vue.nextTick（）的使用
循环队列的一个简单实现
靠谱-ing
10-07 1011
    这是笔试中遇到的一道题，要求实现循环队列，有入队，出队，判断是否为空，是否满等操作。     分析：     可以使用一个数组来存放循环队列，队头标记与队尾标记初始都为0，入队操作即队尾标记加1，若加1后相对循环等于队头则上溢；出队操作即队头标记加1，若加1后相对循环等于队尾则下溢；若队头标记等于队尾标记则为空；若队尾标记加1相对循环等于队头则为满。     具体实现如下： tem
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值