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

之前写过一篇文章叫《写了一段高端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语言的链表。这里就不贴出他们的实现了，大家可以自己实现一套，当作个小练习，不难。

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

查看全文

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