RT-Thread线程间同步(信号量, 互斥量, 事件集)--02源码分析

发布时间：2026/7/9 7:24:20

RT-Thread线程间同步(信号量, 互斥量, 事件集)--02源码分析

源码分析

使用看上一篇API使用

信号量

/*** Semaphore structure*/
struct rt_semaphore
{struct rt_ipc_object parent;                        /**< inherit from ipc_object */rt_uint16_t          value;                         /**< value of semaphore. 信号量的值*/rt_uint16_t          reserved;                      /**< reserved field 保留*/
};
typedef struct rt_semaphore *rt_sem_t;

/*** Base structure of IPC object*/
struct rt_ipc_object
{struct rt_object parent;                            /**< inherit from rt_object */rt_list_t        suspend_thread;                    /**< threads pended on this 														resource 希望获取这一个的线程 */
};

创建

rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag)
{rt_sem_t sem;/* allocate object 获取一个对象, 这一个是对象处理的时候分析过了 */sem = (rt_sem_t)rt_object_allocate(RT_Object_Class_Semaphore, name);if (sem == RT_NULL)return sem;/* initialize ipc object 初始化以及记录链表的信息*/rt_ipc_object_init(&(sem->parent));/* set initial value */sem->value = value;/* set parent */sem->parent.parent.flag = flag;return sem;
}

//初始化一个链表
rt_inline rt_err_t rt_ipc_object_init(struct rt_ipc_object *ipc)
{/* initialize ipc object */rt_list_init(&(ipc->suspend_thread));return RT_EOK;
}

删除

rt_err_t rt_sem_delete(rt_sem_t sem)
{RT_DEBUG_NOT_IN_INTERRUPT;/* wakeup all suspended threads 唤醒所有的在等待这一个线程的任务, 把他们的错误标志位设置为错误 */rt_ipc_list_resume_all(&(sem->parent.suspend_thread));/* delete semaphore object 把这一个对象放在删除队列里面, 空闲任务的时候会处理 */rt_object_delete(&(sem->parent.parent));return RT_EOK;
}

rt_inline rt_err_t rt_ipc_list_resume_all(rt_list_t *list)
{struct rt_thread *thread;register rt_ubase_t temp;/* wakeup all suspended threads */while (!rt_list_isempty(list)){//这一个信号量有正在等待他的线程 /* disable interrupt 临界区 */temp = rt_hw_interrupt_disable();/* get next suspended thread 获取一个线程的控制块 */thread = rt_list_entry(list->next, struct rt_thread, tlist);/* set error code to RT_ERROR 线程的标志位改为错误 */thread->error = -RT_ERROR;/** resume thread 恢复这一个线程的运行, 关闭线程时钟* In rt_thread_resume function, it will remove current thread from* suspended list*/rt_thread_resume(thread);/* enable interrupt */rt_hw_interrupt_enable(temp);}return RT_EOK;
}

获取

rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time)
{register rt_base_t temp;struct rt_thread *thread;//回调函数RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(sem->parent.parent)));/* disable interrupt 临界区 */temp = rt_hw_interrupt_disable();//Debug信息打印RT_DEBUG_LOG(RT_DEBUG_IPC, ("thread %s take sem:%s, which value is: %d\n",rt_thread_self()->name,((struct rt_object *)sem)->name,sem->value));if (sem->value > 0){//这时候还有可以申请的/* semaphore is available */sem->value --;/* enable interrupt */rt_hw_interrupt_enable(temp);}else{//没有可以使用的资源了/* no waiting, return with timeout */if (time == 0){//不想等待rt_hw_interrupt_enable(temp);return -RT_ETIMEOUT;}else{//有一个等待时间, 需要挂起/* current context checking */RT_DEBUG_IN_THREAD_CONTEXT;/* semaphore is unavailable, push to suspend list *//* get current thread *///获取当前的线程thread = rt_thread_self();/* reset thread error number *///改变一下线程的错误值thread->error = RT_EOK;RT_DEBUG_LOG(RT_DEBUG_IPC, ("sem take: suspend thread - %s\n",thread->name));/* suspend thread *///把这个线程插入链表里面rt_ipc_list_suspend(&(sem->parent.suspend_thread),thread,sem->parent.parent.flag);/* has waiting time, start thread timer */if (time > 0){RT_DEBUG_LOG(RT_DEBUG_IPC, ("set thread:%s to timer list\n",thread->name));/* reset the timeout of thread timer and start it 使用这一个线程的时钟进行唤醒 */rt_timer_control(&(thread->thread_timer),RT_TIMER_CTRL_SET_TIME,&time);rt_timer_start(&(thread->thread_timer));}/* enable interrupt */rt_hw_interrupt_enable(temp);/* do schedule 获取当前优先级最高的函数并切换过去 */rt_schedule();//这个时候1.获取到了2.超时3.信号量没了if (thread->error != RT_EOK){//出现错误了return thread->error;}}}RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(sem->parent.parent)));return RT_EOK;
}

rt_inline rt_err_t rt_ipc_list_suspend(rt_list_t        *list,struct rt_thread *thread,rt_uint8_t        flag)
{/* suspend thread */rt_thread_suspend(thread);switch (flag){case RT_IPC_FLAG_FIFO://按照先进先出的方式进行添加rt_list_insert_before(list, &(thread->tlist));break;case RT_IPC_FLAG_PRIO:{//按照优先级的模式进行添加struct rt_list_node *n;struct rt_thread *sthread;/* find a suitable position 遍历一下链表获取一个合适的位置 */for (n = list->next; n != list; n = n->next){sthread = rt_list_entry(n, struct rt_thread, tlist);/* find out */if (thread->current_priority < sthread->current_priority){/* insert this thread before the sthread 把这个线程插入进去 */rt_list_insert_before(&(sthread->tlist), &(thread->tlist));break;}}/* 这一个线程的优先级是链表里面最低的放在最后* not found a suitable position,* append to the end of suspend_thread list*/if (n == list)rt_list_insert_before(list, &(thread->tlist));}break;}return RT_EOK;
}

rt_err_t rt_sem_trytake(rt_sem_t sem)
{	//一个不延时的获取信号量return rt_sem_take(sem, 0);
}

释放

rt_err_t rt_sem_release(rt_sem_t sem)
{register rt_base_t temp;register rt_bool_t need_schedule;need_schedule = RT_FALSE;//记录一下需不需要任务的切换/* disable interrupt 临界区 */temp = rt_hw_interrupt_disable();RT_DEBUG_LOG(RT_DEBUG_IPC, ("thread %s releases sem:%s, which value is: %d\n",rt_thread_self()->name,((struct rt_object *)sem)->name,sem->value));//看一看有么有挂起的任务if (!rt_list_isempty(&sem->parent.suspend_thread)){/* resume the suspended thread *///把一个任务释放出来, 这一个任务获取到这一个信号量, 下面有分析rt_ipc_list_resume(&(sem->parent.suspend_thread));need_schedule = RT_TRUE;}elsesem->value ++; /* increase value *//* enable interrupt */rt_hw_interrupt_enable(temp);/* resume a thread, re-schedule 之前记录的需要切换任务 */if (need_schedule == RT_TRUE)rt_schedule();return RT_EOK;
}

rt_inline rt_err_t rt_ipc_list_resume(rt_list_t *list)
{struct rt_thread *thread;/* get thread entry */thread = rt_list_entry(list->next, struct rt_thread, tlist);RT_DEBUG_LOG(RT_DEBUG_IPC, ("resume thread:%s\n", thread->name));/* resume it 恢复一个线程, 把线程时钟关了 */rt_thread_resume(thread);return RT_EOK;
}

互斥量

struct rt_mutex
{struct rt_ipc_object parent;                        /**< inherit from ipc_object */rt_uint16_t          value;                         /**< value of mutex 值*/rt_uint8_t           original_priority;             /**< priority of last thread holdthe mutex 持有的线程的原优先级*/rt_uint8_t           hold;                          /**< numbers of thread hold themutex 持有线程的持有次数*/struct rt_thread    *owner;                         /**< current owner of mutex 当前拥有互斥量的线程*/
};

创建

//一个标准的对象创建, 和信号量基本一致
rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag)
{struct rt_mutex *mutex;RT_DEBUG_NOT_IN_INTERRUPT;/* allocate object */mutex = (rt_mutex_t)rt_object_allocate(RT_Object_Class_Mutex, name);if (mutex == RT_NULL)return mutex;/* initialize ipc object */rt_ipc_object_init(&(mutex->parent));mutex->value              = 1;mutex->owner              = RT_NULL;mutex->original_priority  = 0xFF;mutex->hold               = 0;/* set flag */mutex->parent.parent.flag = flag;return mutex;
}

释放

rt_err_t rt_mutex_delete(rt_mutex_t mutex)
{RT_DEBUG_NOT_IN_INTERRUPT;/* wakeup all suspended threads 唤醒所有的线程, 上面分析过了 */rt_ipc_list_resume_all(&(mutex->parent.suspend_thread));/* delete mutex object 等待释放 */rt_object_delete(&(mutex->parent.parent));return RT_EOK;
}

获取

rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time)
{register rt_base_t temp;struct rt_thread *thread;//这一个函数不可以在中断里面使用, 这时候的优先级是无效的/* this function must not be used in interrupt even if time = 0 */RT_DEBUG_IN_THREAD_CONTEXT;/* get current thread 获取当前的线程*/thread = rt_thread_self();/* disable interrupt 临界区 */temp = rt_hw_interrupt_disable();/* reset thread error */thread->error = RT_EOK;//看一下是不是一个线程的重复上锁if (mutex->owner == thread){/* it's the same thread 是的*/mutex->hold ++;}else{
__again:/* The value of mutex is 1 in initial status. Therefore, if the* value is great than 0, it indicates the mutex is avaible.*/if (mutex->value > 0){//这是第一次上锁是可以获取的状态/* mutex is available */mutex->value --;/* set mutex owner and original priority 记录一下这个线程的优先级 */mutex->owner             = thread;mutex->original_priority = thread->current_priority;mutex->hold ++;}else{/* no waiting, return with timeout 这个互斥量已经被拥有了 */if (time == 0){//不需要等待/* set error as timeout */thread->error = -RT_ETIMEOUT;/* enable interrupt */rt_hw_interrupt_enable(temp);return -RT_ETIMEOUT;}else{//等待这线互斥量被释放/* mutex is unavailable, push to suspend list */RT_DEBUG_LOG(RT_DEBUG_IPC, ("mutex_take: suspend thread: %s\n",thread->name));//调整一下优先级, 以防被优先级反转/* change the owner thread priority of mutex */if (thread->current_priority < mutex->owner->current_priority){//持有者的优先级比较低, 需要进行升级/* change the owner thread priority */rt_thread_control(mutex->owner,RT_THREAD_CTRL_CHANGE_PRIORITY,&thread->current_priority);}/* suspend current thread 把这一个线程归入挂起的队列里面(按互斥量的获取规则) */rt_ipc_list_suspend(&(mutex->parent.suspend_thread),thread,mutex->parent.parent.flag);/* has waiting time, start thread timer 使能这一个线程的时钟用于唤醒 */if (time > 0){RT_DEBUG_LOG(RT_DEBUG_IPC,("mutex_take: start the timer of thread:%s\n",thread->name));/* reset the timeout of thread timer and start it */rt_timer_control(&(thread->thread_timer),RT_TIMER_CTRL_SET_TIME,&time);rt_timer_start(&(thread->thread_timer));}/* enable interrupt */rt_hw_interrupt_enable(temp);/* do schedule 开启任务切换 */rt_schedule();//这个时候以及获取到或者失败if (thread->error != RT_EOK){//失败了/* interrupt by signal, try it again */if (thread->error == -RT_EINTR) goto __again;//这一个分支是使用信号//机制打断的时候的处理/* return error */return thread->error;}else{/* the mutex is taken successfully. *//* disable interrupt */temp = rt_hw_interrupt_disable();}}}}/* enable interrupt */rt_hw_interrupt_enable(temp);RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mutex->parent.parent)));return RT_EOK;
}

释放

rt_err_t rt_mutex_release(rt_mutex_t mutex)
{register rt_base_t temp;struct rt_thread *thread;rt_bool_t need_schedule;need_schedule = RT_FALSE;/* only thread could release mutex because we need test the ownership 不可以在中断里面使用 */RT_DEBUG_IN_THREAD_CONTEXT;/* get current thread */thread = rt_thread_self();/* disable interrupt */temp = rt_hw_interrupt_disable();RT_DEBUG_LOG(RT_DEBUG_IPC,("mutex_release:current thread %s, mutex value: %d, hold: %d\n",thread->name, mutex->value, mutex->hold));RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mutex->parent.parent)));/* mutex only can be released by owner 只有拥有这一个互斥量的线程可以释放它 */if (thread != mutex->owner){//没有释放的权利thread->error = -RT_ERROR;/* enable interrupt */rt_hw_interrupt_enable(temp);return -RT_ERROR;}/* decrease hold */mutex->hold --;/* if no hold */if (mutex->hold == 0){//这是最后一层的释放/* change the owner thread to original priority */if (mutex->original_priority != mutex->owner->current_priority){rt_thread_control(mutex->owner,RT_THREAD_CTRL_CHANGE_PRIORITY,&(mutex->original_priority));}/* wakeup suspended thread 看一看有没有在等待的线程 */if (!rt_list_isempty(&mutex->parent.suspend_thread)){/* get suspended thread 获取一下下一个等待的线程 */thread = rt_list_entry(mutex->parent.suspend_thread.next,struct rt_thread,tlist);RT_DEBUG_LOG(RT_DEBUG_IPC, ("mutex_release: resume thread: %s\n",thread->name));/* set new owner and priority 记录信息 */mutex->owner             = thread;mutex->original_priority = thread->current_priority;mutex->hold ++;/* resume thread 把这一个线程从等待队列里面取出来以及关闭时钟, 前面有分析 */rt_ipc_list_resume(&(mutex->parent.suspend_thread));need_schedule = RT_TRUE;}else{//最外层并且没有在等待的线程//设置为空闲的状态/* increase value */mutex->value ++;/* clear owner */mutex->owner             = RT_NULL;mutex->original_priority = 0xff;}}/* enable interrupt */rt_hw_interrupt_enable(temp);/* perform a schedule */if (need_schedule == RT_TRUE)rt_schedule();return RT_EOK;
}

事件集

struct rt_event
{struct rt_ipc_object parent;                        /**< inherit from ipc_object */rt_uint32_t          set;                           /**< event set 记录事件, 每一bit表示1个事件 */
};

创建以及释放和上面基本一样–略

发送事件

rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set)
{struct rt_list_node *n;struct rt_thread *thread;register rt_ubase_t level;register rt_base_t status;rt_bool_t need_schedule;if (set == 0)//没有要发送的事件return -RT_ERROR;need_schedule = RT_FALSE;/* disable interrupt 临界区 */level = rt_hw_interrupt_disable();/* set event 设置一下对应的位 */event->set |= set;if (!rt_list_isempty(&event->parent.suspend_thread)){//这个队列里面有在等待的事件, 遍历一遍看一看有没有可以释放的/* search thread list to resume thread */n = event->parent.suspend_thread.next;while (n != &(event->parent.suspend_thread)){/* get thread */thread = rt_list_entry(n, struct rt_thread, tlist);status = -RT_ERROR;//记录一下可不可以释放if (thread->event_info & RT_EVENT_FLAG_AND){//使用AND的方式比较if ((thread->event_set & event->set) == thread->event_set){/* received an AND event */status = RT_EOK;}}else if (thread->event_info & RT_EVENT_FLAG_OR){//使用OR的方式进行比较if (thread->event_set & event->set){/* save the received event set 传递一下当前的事件 */thread->event_set = thread->event_set & event->set;/* received an OR event */status = RT_EOK;}}/* move node to the next 下一个链表记录一下*/n = n->next;/* condition is satisfied, resume thread */if (status == RT_EOK){//需要释放这一个任务/* clear event */if (thread->event_info & RT_EVENT_FLAG_CLEAR)event->set &= ~thread->event_set;//需要清除这一个事件/* resume thread, and thread list breaks out 释放这一个任务 */rt_thread_resume(thread);/* need do a scheduling 记录一下需要进行任务切换 */need_schedule = RT_TRUE;}}}/* enable interrupt */rt_hw_interrupt_enable(level);/* do a schedule */if (need_schedule == RT_TRUE)rt_schedule();return RT_EOK;
}

接收事件

rt_err_t rt_event_recv(rt_event_t   event,rt_uint32_t  set,rt_uint8_t   option,rt_int32_t   timeout,rt_uint32_t *recved)
{struct rt_thread *thread;register rt_ubase_t level;register rt_base_t status;if (set == 0)//没有等待的事件return -RT_ERROR;/* initialize status */status = -RT_ERROR;/* get current thread 获取当前的任务 */thread = rt_thread_self();/* reset thread error */thread->error = RT_EOK;/* disable interrupt 临界区 */level = rt_hw_interrupt_disable();/* check event set 看一看这一个事件是不是已经达成了 */if (option & RT_EVENT_FLAG_AND){if ((event->set & set) == set)status = RT_EOK;}else if (option & RT_EVENT_FLAG_OR){if (event->set & set)status = RT_EOK;}else{/* either RT_EVENT_FLAG_AND or RT_EVENT_FLAG_OR should be set */RT_ASSERT(0);}if (status == RT_EOK){//这个事件已经实现了, 记录一下当前的情况/* set received event */if (recved)*recved = (event->set & set);/* received event */if (option & RT_EVENT_FLAG_CLEAR)//需要清除标志位event->set &= ~set;}else if (timeout == 0){//事件没有达成, 但是不等待/* no waiting */thread->error = -RT_ETIMEOUT;}else{/* fill thread event info */thread->event_set  = set;thread->event_info = option;/* put thread to suspended thread list 把这一个任务挂起 */rt_ipc_list_suspend(&(event->parent.suspend_thread),thread,event->parent.parent.flag);/* if there is a waiting timeout, active thread timer 使用时钟进行唤醒 */if (timeout > 0){/* reset the timeout of thread timer and start it */rt_timer_control(&(thread->thread_timer),RT_TIMER_CTRL_SET_TIME,&timeout);rt_timer_start(&(thread->thread_timer));}/* enable interrupt */rt_hw_interrupt_enable(level);/* do a schedule 任务切换 */rt_schedule();//这时候获取到事件或者时间到了if (thread->error != RT_EOK){//出错了(比如超时)/* return error */return thread->error;}/* received an event, disable interrupt to protect */level = rt_hw_interrupt_disable();/* set received event */if (recved)//记录一下当前的事件*recved = thread->event_set;}/* enable interrupt */rt_hw_interrupt_enable(level);return thread->error;
}

相关新闻

Android13源码下载及全编译流程

Android13源码下载及全编译流程

目录 一、源码下载 1.1、配置要求 1.1.1、硬件配置要求 1.1.2、软件要求 1.2、下载环境搭建 1.2.1、依赖安装 1.2.2、工具安装 1.2.3、git配置 1.2.4、repo配置 1.3、源码下载 1.3.1、明确下载版本 1.3.2、替换为清华源 1.3.3、初始化仓库并指定分支 1.3.4、同步全部源码 二、…

2026/7/5 17:45:17
[python]基于Ultra-Fast-Lane-Detection-v2车道线实时检测onnx部署

[python]基于Ultra-Fast-Lane-Detection-v2车道线实时检测onnx部署

【论文地址】 https://arxiv.org/pdf/2206.07389.pdf 【框架地址】 https://github.com/cfzd/Ultra-Fast-Lane-Detection-v2 【框架介绍】 Ultra-Fast-Lane-Detection-v2&#xff08;UFL-D-v2&#xff09;算法是一种高效的车道线检测算法&#xff0c;它旨在快速准确地识别…

2026/7/9 10:37:07
【从零开始的rust web开发之路 四】rust语言tokio异步使用redis教程

【从零开始的rust web开发之路 四】rust语言tokio异步使用redis教程

文章目录 前言一、首先引入依赖二、创建redis客户端三、相关操作设置值mset设置多个key值设置含有过期时间的值如果key不存在才设置获取基本类型值删除一个键删除多个键判断键是否存在 如何使用json序列化导入相关依赖代码相关实例 总结 前言 使用rust写web&#xff0c;自然是…

2026/6/17 16:59:00

最新新闻

大模型在非可验证领域的技术突破与应用实践

大模型在非可验证领域的技术突破与应用实践

&#x1f680; 30款热门AI模型一站整合&#xff0c;DeepSeek/GLM/Qwen 随心用&#xff0c;限时 5 折。 &#x1f449; 点击领海量免费额度 大模型技术已经不再局限于数学、编程、科学等可验证领域&#xff0c;在创意写作、艺术设计、情感分析、开放对话等非可验证领域同样展…

2026/7/10 2:01:47
基于Dify与DeepSeek-V3构建企业级AI知识库：从部署到优化的完整实践指南

基于Dify与DeepSeek-V3构建企业级AI知识库：从部署到优化的完整实践指南

&#x1f680; 30款热门AI模型一站整合&#xff0c;DeepSeek/GLM/Qwen 随心用&#xff0c;限时 5 折。 &#x1f449; 点击领海量免费额度 如果你正在寻找一个既能快速搭建又能深度定制的AI知识库方案&#xff0c;那么“Dify DeepSeek”这个组合&#xff0c;很可能就是你当…

2026/7/10 2:01:47
ThinkPHP 8.0 职工健康数据管理系统：从选题到部署的 3 个关键实现步骤

ThinkPHP 8.0 职工健康数据管理系统：从选题到部署的 3 个关键实现步骤

ThinkPHP 8.0 职工健康数据管理系统实战&#xff1a;从零构建企业级应用的三大核心策略当企业健康管理遇上数字化浪潮&#xff0c;一套高效的职工健康数据管理系统已成为现代组织的刚需。作为PHP开发者&#xff0c;我们如何在毕业设计或实际项目中快速构建这样的系统&#xff1…

2026/7/10 2:01:47
Unity移动开发必备：ADB环境变量配置与调试效率提升指南

Unity移动开发必备：ADB环境变量配置与调试效率提升指南

1. 项目概述&#xff1a;为什么Unity开发者必须搞定ADB环境变量&#xff1f;如果你是一名Unity开发者&#xff0c;尤其是涉足移动平台&#xff08;Android&#xff09;开发&#xff0c;那么“ADB环境变量”这个词组对你来说&#xff0c;绝对不是一个可有可无的配置项。它就像是…

2026/7/10 2:01:47
深入解析VMware NAT网络与Ubuntu高效配置指南

深入解析VMware NAT网络与Ubuntu高效配置指南

一、VMware NAT 网络原理 网络架构 Windows 宿主机 VMware 后台 Ubuntu 虚拟机│ │ │ VMnet8 网卡 NAT 服务 ens33 网卡 192.168.84.1 ←───…

2026/7/10 2:01:47
STM32与ADS1262高精度数据采集系统设计与优化

STM32与ADS1262高精度数据采集系统设计与优化

1. 项目背景与核心挑战在工业测量、医疗设备和精密仪器领域&#xff0c;高精度模拟信号采集一直是工程师面临的核心难题。ADS1262作为TI推出的32位Δ-Σ模数转换器(ADC)&#xff0c;其噪声水平低至7nV/√Hz&#xff0c;而STM32F205RB则是ST旗下基于Cortex-M3内核的微控制器&…

2026/7/10 2:01:47

日新闻

npm全局命令not found的7个精准修复方案

npm全局命令not found的7个精准修复方案

1. 项目概述&#xff1a;为什么“codex: command not found”成了2026年开发者桌面的高频报错&#xff1f; “codex: command not found”——这行红色错误提示&#xff0c;最近半年在终端里出现的频率&#xff0c;已经快赶上 git status 的刷新次数了。它不是某个冷门工具的…

2026/7/10 0:00:24
蓝牙 5.4 协议栈深度解析：从 HCI 到 L2CAP 的 7 层数据流

蓝牙 5.4 协议栈深度解析：从 HCI 到 L2CAP 的 7 层数据流

蓝牙 5.4 协议栈深度解析&#xff1a;从 HCI 到 L2CAP 的 7 层数据流当你的无线耳机与手机瞬间完成配对&#xff0c;或是键盘在十米外依然稳定响应时&#xff0c;背后是蓝牙协议栈在精密协调着每一次数据交互。作为最新演进的蓝牙5.4版本&#xff0c;其协议栈架构在保持向下兼容…

2026/7/10 0:00:24
安徽省豆包排名哪家实力强 - 招财兔数字员工

安徽省豆包排名哪家实力强 - 招财兔数字员工

产品名称：豆包排名 产品介绍：帮助全国各行各业的企业客户，优化在豆包等AI平台里的提及率和排名。联系人：杨经理联系电话：18452273182(杨科)本文来自博客园，作者：招财兔数字员工，转载请注明原文链接：https://w…

2026/7/10 0:00:24

周新闻

3步彻底解决Windows右键菜单混乱问题：ContextMenuManager使用全攻略

3步彻底解决Windows右键菜单混乱问题：ContextMenuManager使用全攻略

3步彻底解决Windows右键菜单混乱问题&#xff1a;ContextMenuManager使用全攻略 【免费下载链接】ContextMenuManager &#x1f5b1;️ 纯粹的Windows右键菜单管理程序 项目地址: https://gitcode.com/gh_mirrors/co/ContextMenuManager 你是否曾为Windows右键菜单中那些…

2026/7/9 15:31:50
GXDE OS下Wayland兼容性实战：从deepin-mutter原理到VMware Tools修复

GXDE OS下Wayland兼容性实战：从deepin-mutter原理到VMware Tools修复

如果你正在用 GXDE OS 或者任何基于 Deepin 的发行版&#xff0c;并且遇到了“检测到窗口系统采用 Wayland 协议&#xff0c;程序即将退出”这类弹窗&#xff0c;或者发现 VMware Tools 在 Ubuntu 24.04 这类默认 Wayland 的系统上启动失败&#xff0c;那这篇文章就是为你准备的…

2026/7/9 14:30:13
企业AI落地困境与AgenticOps实践指南

企业AI落地困境与AgenticOps实践指南

1. 企业AI落地的现实困境与破局之道过去两年&#xff0c;大模型技术呈现爆发式增长&#xff0c;从GPT-3到GPT-4&#xff0c;从LLaMA到DeepSeek&#xff0c;模型参数规模从百亿级跃升至万亿级&#xff0c;多模态能力从单一文本扩展到图文音视频的综合处理。然而在企业应用层面&a…

2026/7/9 11:54:04

月新闻

[C++]内存管理：串顺序存储的内存回收

[C++]内存管理：串顺序存储的内存回收

在串&#xff08;字符串&#xff09;的顺序存储中&#xff0c;内存回收的方式取决于字符串的存储方式以及所使用的编程语言和相关库。以下以 C 为例进行说明&#xff0c;因为 C 对内存管理有较为直接的控制。 1. 基于 char 数组的串顺序存储 如果使用普通的 char 数组来存储字…

2026/7/9 23:58:49
移动端游戏功耗测试实战：电流、功率、亮度和场景对比

移动端游戏功耗测试实战：电流、功率、亮度和场景对比

移动端游戏功耗测试：先控制变量，再比较优化是否真的省电 摘要：功耗测试最容易犯的错误，是拿两次不同温度、不同亮度、不同场景的平均功率直接比较。本文给出一套可复现的游戏功耗测试方法，覆盖引擎特性验证、版本回归和黑盒体验测试，并说明如何把功耗与帧率、温控、CPU/G…

2026/7/9 14:31:03
足球口袋教练 HarmonyOS 离线应用实战（03/20）：ArkUI 首页仪表盘搭建

足球口袋教练 HarmonyOS 离线应用实战（03/20）：ArkUI 首页仪表盘搭建

本文是“足球口袋教练 HarmonyOS 离线应用实战”系列第 3 篇。示例项目是一个 HarmonyOS / ArkTS / ArkUI 编写的离线足球训练助手&#xff0c;围绕真实页面、真实截图和可复现操作展开。 本篇要解决的问题 训练 App 的首页不能只展示欢迎语&#xff0c;它要解决“我现在该点哪…

2026/7/9 15:31:26