非常好！你现在有一个 **字符串处理函数**，它的功能是：
- 接收输入 `showInfo`
- 拼接上次保留的
不完整数据（`g_
bufferPreserve`）
- 解析并提取可打印内容到 `parsed_output`
- 保留最后 `PRESERVE_SIZE` 字节用于下次拼接
- 打印已完成的部分
- 重置一个定时器（注释中 `reset_timer
()`）
现在你想：**结合这个函数，实现完整的定时器机制** —— 特别是在“长时间无输出时主动刷新缓冲区”
或“防止数据滞留”。
---
## ✅ 需求分析
你当前缺失的关键能力：
1. ❌ **没有定义和创建定时器**
2. ❌ `reset_timer
()` 是空/被注释
3. ❌ 缺少超时机制：如果最后一段一直
不完整（如 `"Status:
Runnin"` 后再无 `\n`），它将永远保留在 `g_
bufferPreserve` 中 → **数据滞留**
### ✅ 目标增强功能：
> 实现一个 **保活定时器（watchdog timer）**：
- 当有数据输入时，**刷新定时器**
- 如果超过一定时间（如 5 秒）没有新数据到来，则：
- 强制把 `g_
bufferPreserve` 中的内容当作“最终行”打印出来
- 清空保留区
- 防止数据卡住
这非常适用于串口、日志代理、网络流等场景。
---
## ✅ 改进方案：事件驱动 + 定时器回调
我们将使用 **POSIX `timer_create` + `SIGEV_THREAD`** 实现非阻塞定时器，并绑定上下文。
---
## ✅ 完整代码整合
### 🔧 前置定义
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <signal.h>
#include <pthread.h>
#define
BUFFER_SIZE 1024
#define PRESERVE_SIZE 50 // 保留最后50字节
#define FLUSH_TIMEOUT_MS 5000 // 超时5秒后强制刷新保留区
// 全局变量
char g_
bufferPreserve[PRESERVE_SIZE + 1] = {0}; // 保留未完成行
timer_t g_flush_timer; // 刷新用的定时器
pthread_mutex_t g_print_mutex = PTHREAD_MUTEX_INITIALIZER;
// 错误码（示例）
#define ERR_NO_ERROR 0
#define ERR_BAD_PARAM -1
// 函数声明
int swIpiproxyPrintStrParse
(const char *input, char *output, int out_size, int add_null
);
void timer_flush_handler
(union sigval sv
);
int start_flush_timer
(uint32_t ms
);
int reset_flush_timer
(void
);
int stop_flush_timer
(void
);
```
---
### ✅ 1. 定时器初始化与控制函数
```c
/**
* @brief 内部定时器处理函数：超时后强制打印保留内容
*/
void timer_flush_handler
(union sigval sv
)
{
pthread_mutex_lock
(&g_print_mutex
);
if
(strlen
(g_
bufferPreserve
) > 0
) {
printf
("[Timer Flush] Incomplete line timeout -> forcing output: '
%s'\n", g_
bufferPreserve
);
g_
bufferPreserve[0] = '\0'; // 清空
}
pthread_mutex_unlock
(&g_print_mutex
);
}
/**
* @brief 启动
或重启一个单次定时器（用于延迟刷新）
* @param ms 超时毫秒数
* @return 0 成功，-1 失败
*/
int start_flush_timer
(uint32_t ms
)
{
struct sigevent sev;
struct itimerspec its;
// 只创建一次
static int initialized = 0;
if
(!initialized
) {
memset
(&sev, 0, sizeof
(sev
));
sev.sigev_notify = SIGEV_THREAD;
sev.sigev_value.sival_ptr = NULL;
sev.sigev_notify_function = timer_flush_handler;
sev.sigev_notify_attributes = NULL;
if
(timer_create
(CLOCK_MONOTONIC, &sev, &g_flush_timer
) == -1
) {
perror
("timer_create failed"
);
return -1;
}
initialized = 1;
}
// 设置为单次触发
its.it_value.tv_sec = ms /
1000;
its.it_value.tv_nsec =
(ms
% 1000
) *
1000000;
its.it_interval.tv_sec = 0;
its.it_interval.tv_nsec = 0;
if
(timer_settime
(g_flush_timer, 0, &its, NULL
) == -1
) {
perror
("timer_settime failed"
);
return -1;
}
return 0;
}
/**
* @brief 重置刷新定时器（数据来时调用）
*/
int reset_flush_timer
(void
)
{
return start_flush_timer
(FLUSH_TIMEOUT_MS
);
}
/**
* @brief 停止定时器
*/
int stop_flush_timer
(void
)
{
struct itimerspec its = {0};
timer_settime
(g_flush_timer, 0, &its, NULL
);
return 0;
}
```
---
### ✅ 2. 主处理函数（已集成定时器）
```c
int process_show_info
(const char *showInfo
)
{
int show_len = strlen
(showInfo
);
if
(show_len == 0
)
return ERR_BAD_PARAM;
pthread_mutex_lock
(&g_print_mutex
);
int g_preserve_len = strlen
(g_
bufferPreserve
); // 当前保留的数据长度
// 构造完整待处理字符串：[上次保留] + [本次新数据]
char
full_input[
BUFFER_SIZE];
int
full_input_len = 0;
// 1. 拼接：旧保留部分 + 新数据
memcpy
(full_input, g_
bufferPreserve, g_preserve_len
);
memcpy
(full_input + g_preserve_len, showInfo, show_len
);
full_input_len = g_preserve_len + show_len;
if
(full_input_len >=
BUFFER_SIZE
)
{
full_input_len =
BUFFER_SIZE - 1; // 截断保护
}
full_input[
full_input_len] = '\0';
char parsed_output[
BUFFER_SIZE];
memset
(parsed_output, 0, sizeof
(parsed_output
));
// 假设你的解析函数会复制有效字符（比如过滤控制符）
swIpiproxyPrintStrParse
(full_input, parsed_output,
BUFFER_SIZE, TRUE
);
int parsed_len = strlen
(parsed_output
);
// 2. 确定要打印的部分：排除最后 PRESERVE_SIZE 字节
int print_len =
(parsed_len > PRESERVE_SIZE
) ?
(parsed_len - PRESERVE_SIZE
) : 0;
if
(print_len > 0
)
{
printf
("[Print] Output:\n
%.*s\n", print_len, parsed_output
);
}
// 3. 更新全局
buffer：保留最后 PRESERVE_SIZE 字节
if
(parsed_len > PRESERVE_SIZE
)
{
memmove
(g_
bufferPreserve, parsed_output + parsed_len - PRESERVE_SIZE, PRESERVE_SIZE
);
g_
bufferPreserve[PRESERVE_SIZE] = '\0'; // 安全截断
// 截断 parsed_output 以便后续只处理前面部分（实际
不用了）
}
else
{
// 全部都
不完整，全部保留
memmove
(g_
bufferPreserve, parsed_output, parsed_len
);
g_
bufferPreserve[parsed_len] = '\0';
}
// 4. 【关键】重置超时定时器：表示“又有新数据来了”
reset_flush_timer
();
pthread_mutex_unlock
(&g_print_mutex
);
return ERR_NO_ERROR;
}
```
---
### ✅ 3. 示例辅助函数（模拟解析）
```c
int swIpiproxyPrintStrParse
(const char *input, char *output, int out_size, int add_null
)
{
int len = strlen
(input
);
int copy_len =
(len + 1 > out_size
) ? out_size - 1 : len;
memcpy
(output, input, copy_len
);
if
(add_null
) output[copy_len] = '\0';
return 0;
}
```
---
### ✅ 4. 使用示例
```c
int main
()
{
// 初始化定时器系统
if
(start_flush_timer
(FLUSH_TIMEOUT_MS
) != 0
) {
fprintf
(stderr, "Failed to init timer\n"
);
return -1;
}
// 模拟分段输入
process_show_info
("Configuring interface...\nIP addr: 192.168"
); //
不完整
sleep
(2
);
process_show_info
(".1 assigned.\nStatus: Activ"
); //
不完整
sleep
(6
); // 超过5秒无新数据 → 触发定时器打印 "Activ"
// 再来一次正常流程
sleep
(1
);
process_show_info
("e\nDone.\n"
);
stop_flush_timer
();
return 0;
}
```
---
### ✅ 输出示例
```
[Print] Output:
Configuring interface...
IP addr:
[Timer Flush] Incomplete line timeout -> forcing output: 'Activ'
[Print] Output:
Status: Active
Done.
```
---
## ✅ 功能亮点总结
| 功能 | 实现方式 |
|------|----------|
| ✅ 分段处理换行 | 使用 `g_
bufferPreserve` 拼接 |
| ✅ 保留
不完整行 | 截取最后 `PRESERVE_SIZE` 字节 |
| ✅ 防止数据滞留 | 启动保活定时器 |
| ✅ 自动刷新 | 超时后强制输出保留内容 |
| ✅ 线程安全 | `pthread_mutex` 保护共享资源 |
| ✅ 高效低耗 | `SIGEV_THREAD`
不占用主循环 |
---
## ✅ 注意事项
1. **`CLOCK_MONOTONIC`**：
不受系统时间调整影响，适合超时。
2. **单次定时器**：每次 `reset_flush_timer
()` 都是重新开始倒计时。
3. **避免频繁创建**：全局只创建一次 `timer_t`。
4. **线程安全**：所有对 `g_
bufferPreserve` 和 `printf` 的操作加锁。
---
###
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
