虫虫首页| 资源下载| 资源专辑| 精品软件
登录| 注册

您现在的位置是:首页 > 技术阅读 >  写了一段“高端”C语言代码

写了一段“高端”C语言代码

时间:2024-02-11

之前写过一篇文章叫《写了一段高端C++代码》,这篇文章的背景和它完全相同,我这里再复述一遍。

背景:

在音视频方向中,线程分为普通线程和GL线程(OpenGL线程),GL线程中可以执行OpenGL相关的语句,做一些图像渲染的工作,也可以理解为所有GL语句都要在GL线程中执行;而在普通线程中,只能执行那些我们平时经常接触的普通语句。


在具体项目开发中会有些需求:在普通线程中突然想要执行某些必须要在GL线程下执行的任务(比如某些初始化工作,释放某些GL相关的对象),执行完此任务后又继续执行自己的任务,像在同一个线程执行一样:

void func() {    task1();    task2(); // 需要在GL线程执行    task3();}


分析:

这里有个关键点:task3()一定要等到task2()执行完毕后才可执行,但是由于task2()是被抛到了其他线程运行,没有起到阻塞执行的效果。


怎么能达到目的呢?可以这样使用条件变量:

void task2() {    ...    notify();}
void func() { task1(); task2(); // 需要在GL线程执行 wait(); task3();}

普通线程在task2()后使用wait()阻塞线程,待GL线程中的任务执行完后使用notity()打断普通线程的阻塞,可达到顺序执行的目的。


但这样非常麻烦,而且不通用,代码还相当难看。

在之前的文章里我使用C++的future封装了一套函数,可以方便的跨线程阻塞调度某个任务执行,然而我还有个项目是使用纯C语言开发的,没有了C++的future,要完成类似需求就比较困难,但是,困难也得搞阿,于是有了下面的代码。


先看下如何函数的设计:

#ifndef __GL_DISPATCH_H__#define __GL_DISPATCH_H__#include <stdbool.h>
typedef struct Dispatcher Dispatcher;typedef void (*DispatcherFunc)(void* arg);/** * @brief 创建一个实例,内部会常驻一个GL线程,外部可以将某些任务丢到此线程里执行,可以选择是否阻塞执行 */Dispatcher* Dispatcher_create();/** * @brief 销毁实例 */void Dispatcher_destroy(Dispatcher** dispatcher_p);/** * @brief 利用此函数将任务丢到线程里执行 * * @param dispatcher 实例 * @param func 要执行的函数 * @param arg 函数参数 * @param block 选择是否阻塞执行 */void Dispatcher_run(Dispatcher* dispatcher, DispatcherFunc func, void* arg, bool block);
#endif // __GL_DISPATCH_H__

主要功能就在最后一个函数,该函数可以选择是否阻塞执行,这里大家可以思考一下,如何实现阻塞的需求?条件变量是肯定的,但是如何保证条件变量等待的是当前事件呢?还是直接看代码实现吧:

#include <stdatomic.h>#include "libctools.h"#include "gldispatch.h"
typedef struct Task { DispatcherFunc func; void* arg; Mutex* mutex; Cond* cond; bool is_continue; bool is_block;} Task;
struct Dispatcher { Thread* thread_id; Thread _thread_id; Mutex* mutex; Cond* cond; List* task_queue; atomic_bool is_interrupt;};
static void taskDestroy(Task* task) { if (task->mutex) { mutex_destroyp(&task->mutex); } if (task->cond) { cond_destroyp(&task->cond); } free((void*)task);}
static Task* taskCreate(DispatcherFunc func, void* arg, bool is_block) { Task* task = (Task*)calloc(1, sizeof(Task)); if (!task) return NULL; task->func = func; task->arg = arg; task->is_block = is_block; if (is_block) { task->mutex = mutex_create(); task->cond = cond_create(); } return task;}
static int Dispatcher_process(void* arg) { log_info("%s start", __func__); Dispatcher* self = (Dispatcher*)arg; while (!atomic_load(&self->is_interrupt)) { mutex_lock(self->mutex); while (self->task_queue->len == 0 && !atomic_load(&self->is_interrupt)) { cond_wait(self->cond, self->mutex); } ListNode* node = list_pop_front(self->task_queue); mutex_unlock(self->mutex); if (atomic_load(&self->is_interrupt)) { break; } if (node) { Task* task = (Task*)node->val; task->func(task->arg); if (task->is_block) { mutex_lock(task->mutex); task->is_continue = true; cond_signal(task->cond); mutex_unlock(task->mutex); } else { taskDestroy(task); } free(node); } } log_info("%s stop", __func__); return 0;}
static void Dispatcher_start(Dispatcher* dispatcher) { dispatcher->thread_id = thread_create_with_name(&dispatcher->_thread_id, Dispatcher_process, dispatcher, "Dispatcher_process");}
static void Dispatcher_stop(Dispatcher* dispatcher) { atomic_store(&dispatcher->is_interrupt, true); cond_signal(dispatcher->cond); list_clear(dispatcher->task_queue, true); if (dispatcher->thread_id) { thread_wait(dispatcher->thread_id, NULL); }}
Dispatcher* Dispatcher_create() { Dispatcher* self = (Dispatcher*)calloc(1, sizeof(Dispatcher)); if (!self) return NULL; self->mutex = mutex_create(); self->cond = cond_create(); self->task_queue = list_create(); self->task_queue->free_func = (void (*)(int64_t))taskDestroy; Dispatcher_start(self); return self;}
void Dispatcher_destroy(Dispatcher** dispatcher_p) { if (NULL == dispatcher_p || NULL == *dispatcher_p) return; Dispatcher* self = *dispatcher_p; Dispatcher_stop(self); mutex_destroyp(&self->mutex); cond_destroyp(&self->cond); list_destroy(self->task_queue); freep((void**)dispatcher_p);}
void Dispatcher_run(Dispatcher* dispatcher, DispatcherFunc func, void* arg, bool block) { if (!dispatcher) return; Task* task = taskCreate(func, arg, block); if (task) { ListNode* node = list_node_new((int64_t)task); mutex_lock(dispatcher->mutex); list_push_back(dispatcher->task_queue, node); cond_signal(dispatcher->cond); mutex_unlock(dispatcher->mutex); if (task->is_block) { mutex_lock(task->mutex); while (!task->is_continue) { cond_wait(task->cond, task->mutex); } mutex_unlock(task->mutex); taskDestroy(task); } }}

使用方式:

void func1(void* arg) {    print("hello func1");}
void func2(void* arg) { print("hello func2");}
int main() { Dispatcher* dispatcher = Dispatcher_create(); Dispatcher_run(dispatcher, func1, NULL, true); Dispatcher_run(dispatcher, func2, NULL, true); Dispatcher_destroy(&dispatcher); return 0;}

tips:

代码中的log、mutex、cond、thread、list都是二次封装的函数,功能无非就是log、加解锁、条件变量、创建线程以及C语言的链表。这里就不贴出他们的实现了,大家可以自己实现一套,当作个小练习,不难。

代码我也就不过多介绍了,相信有点水平的朋友都能看懂,有问题可以留言!