[libos源码学习 1] Liboc协程生产者消费者举例

1. CoRoutineEnv_t结构体用于管理协程环境

struct stCoRoutineEnv_t
{
stCoRoutine_t *pCallStack[ 128 ];
int iCallStackSize;
stCoEpoll_t *pEpoll;//for copy stack log lastco and nextco
stCoRoutine_t* pending_co;
stCoRoutine_t* occupy_co;};中文描述
stCoRoutineEnv_t结构体是用于协程环境的结构体，它包含了以下几个成员：1. pCallStack：这是一个数组，用于存储协程的调用栈。数组的大小是128，这意味着这个环境可以同时运行128个协程。2. iCallStackSize：这是一个整数，用于记录当前调用栈的大小，也就是正在运行的协程的数量。3. pEpoll：这是一个指向stCoEpoll_t结构体的指针，用于管理协程的事件循环。4. pending_co：这是一个指向stCoRoutine_t结构体的指针，用于表示待处理的协程，也就是在事件循环中等待执行的协程。5. occupy_co：这是一个指向stCoRoutine_t结构体的指针，用于表示当前被占用的协程，也就是正在执行的协程。

中文描述

stCoRoutineEnv_t结构体用于管理协程环境，包括协程的调用栈、调用栈的大小、事件循环以及正在执行和等待执行的协程。它的主要作用是提供一个运行协程的环境，协程可以在这个环境中进行切换，实现并发执行。

结构体成员详解

• pCallStack：这是一个数组，用于存储协程的调用栈。数组的大小是128，这意味着这个环境可以同时运行128个协程。
• iCallStackSize：这是一个整数，用于记录当前调用栈的大小，也就是正在运行的协程的数量。
• pEpoll：这是一个指向stCoEpoll_t结构体的指针，用于管理协程的事件循环。事件循环是协程的核心，它负责管理协程的切换和调度。
• pending_co：这是一个指向stCoRoutine_t结构体的指针，用于表示待处理的协程，也就是在事件循环中等待执行的协程。
• occupy_co：这是一个指向stCoRoutine_t结构体的指针，用于表示当前被占用的协程，也就是正在执行的协程。

结构体的使用

stCoRoutineEnv_t结构体通常用于协程库或框架中，用于管理协程的运行环境。开发者可以使用这个结构体来创建、管理和调度协程，以实现并发执行。

struct stCoRoutine_t
{stCoRoutineEnv_t *env;pfn_co_routine_t pfn;void *arg;coctx_t ctx;char cStart;char cEnd;char cIsMain;char cEnableSysHook;char cIsShareStack;void *pvEnv;//char sRunStack[ 1024 * 128 ];stStackMem_t* stack_mem;//save satck buffer while confilct on same stack_buffer;char* stack_sp; unsigned int save_size;char* save_buffer;stCoSpec_t aSpec[1024];};

#2. stCoRoutine_t协程的实体
stCoRoutine_t结构体定义了一个协程的实体，包含了协程的环境、协程体、参数、上下文、标志位、堆栈内存以及特殊变量等信息。下面是对这个结构体的详细解释：

成员解释

env：指向stCoRoutineEnv_t结构体的指针，表示协程所在的环境。

pfn_co_routine_t pfn：指向协程体的函数指针，表示协程的主体逻辑。

*void arg：协程的参数，传递给协程体的参数。

coctx_t ctx：协程的上下文，用于保存协程的执行状态。

cStart, cEnd, cIsMain, cEnableSysHook, cIsShareStack：这些是字符类型的标志位，用于标记协程的特性，例如是否是主协程、是否启用系统钩子等。

*void pvEnv：未明确指定的环境指针，可能用于特定的协程环境。

stStackMem_t stack_mem*：指向stStackMem_t结构体的指针，用于管理协程的堆栈内存。运行是栈的结构，libco提供了两种方式，一个是每个协程拥有一个独立的栈，默认分配128KB空间，缺点是每个协程可能只用到了1KB不到，碎片较多。还有一种是共享栈模式，需要我们在创建协程的时候在Co_create中指定第二个参数，这种方法是多个协程共用一个栈，但是在协程切换的时候需要拷贝已使用的栈空间。

char stack_sp, unsigned int save_size, char save_buffer**：用于保存堆栈冲突时的堆栈缓冲区信息。

stCoSpec_t aSpec[1024]：一个数组，用于存储协程的特殊变量或特性。

结构体的使用
stCoRoutine_t结构体用于表示一个协程实体，包含了协程的环境、执行体、参数、上下文、标志位、堆栈管理以及特殊变量等信息。开发者可以使用这个结构体来创建、管理和调度协程，以实现并发执行。

3 Liboc协程生产者消费者例子

你提供的代码展示了如何使用协程（co-routine）在生产者-消费者模式下进行任务处理。下面是对代码的详细解释：1. 头文件包含：* #include <unistd.h>：POSIX标准的系统调用库。* #include <stdio.h>：标准输入输出库。* #include <stdlib.h>：标准库。* #include <queue>：C++标准库中的队列。* "co_routine.h"：假设这是你自定义的协程库头文件。2. 任务结构体：struct stTask_t{int id;};stTask_t结构体用于表示任务，其中包含一个任务ID。3. 环境结构体：struct stEnv_t{stCoCond_t* cond;queue<stTask_t*> task_queue;};stEnv_t结构体用于表示协程环境，包含一个条件变量cond和一个任务队列task_queue。4. 生产者协程：void* Producer(void* args){co_enable_hook_sys();stEnv_t* env=  (stEnv_t*)args;int id = 0;while (true){stTask_t* task = (stTask_t*)calloc(1, sizeof(stTask_t));task->id = id++;env->task_queue.push(task);printf("%s:%d produce task %d\n", __func__, __LINE__, task->id);co_cond_signal(env->cond);poll(NULL, 0, 1000);}return NULL;}Producer函数是一个生产者协程，它不断地创建任务并将其放入任务队列中，然后通知消费者协程有新任务到达。co_enable_hook_sys()用于启用协程系统调用hook，co_cond_signal(env->cond)用于通知消费者协程有新任务到达，poll(NULL, 0, 1000)用于阻塞一段时间（1秒）。5. 消费者协程：void* Consumer(void* args){co_enable_hook_sys();stEnv_t* env = (stEnv_t*)args;while (true){if (env->task_queue.empty()){co_cond_timedwait(env->cond, -1);continue;}stTask_t* task = env->task_queue.front();env->task_queue.pop();printf("%s:%d consume task %d\n", __func__, __LINE__, task->id);free(task);}return NULL;}Consumer函数是一个消费者协程，它不断地从任务队列中取出任务并处理。co_cond_timedwait(env->cond, -1)用于在没有任务时等待，直到生产者协程通知有新任务到达。6. 主函数：int main(){stEnv_t* env = new stEnv_t;env->cond = co_cond_alloc();stCoRoutine_t* consumer_routine;co_create(&consumer_routine, NULL, Consumer, env);co_resume(consumer_routine);stCoRoutine_t* producer_routine;co_create(&producer_routine, NULL, Producer, env);co_resume(producer_routine);co_eventloop(co_get_epoll_ct(), NULL, NULL);return 0;}在main函数中，首先创建了一个协程环境env，然后分别创建了生产者和消费者协程，并使用co_resume函数启动它们。最后，使用co_eventloop函数进入事件循环，等待协程的执行完成。说明* 协程创建和启动：使用co_create和co_resume函数创建和启动协程。* 条件变量使用：生产者和消费者协程通过条件变量进行通信，生产者通知消费者有新任务到达。* 任务队列：使用C++标准库中的queue来管理任务队列。* 事件循环：使用co_eventloop函数进入事件循环，等待协程的执行完成。这个示例展示了如何使用协程实现生产者-消费者模式，通过条件变量和任务队列实现协程之间的通信和任务处理。

4 Liboc协程生产者消费者， 为什么队列不需要上锁？

在多线程环境中，使用队列而不需要显式上锁（锁定）主要依赖于以下几个因素：

1. 线程局部存储（Thread Local Storage, TLS）：在你的代码中，使用了__thread关键字来确保每个线程都有自己独立的gCoEnvPerThread变量副本。这意味着每个线程在访问stEnv_t结构体中的task_queue时，都会访问自己独立的队列副本，而不是共享的全局队列。因此，不需要显式上锁，因为每个线程只会影响自己的队列副本。

2. 协程的特性：协程（co-routine）是一种轻量级的线程切换机制，它允许在多个函数之间切换执行，而不需要创建和销毁线程。协程的上下文切换开销比线程要小得多，因此可以更频繁地进行切换。由于协程的特性，协程之间的通信通常不需要复杂的锁机制，因为协程的上下文切换是快速且高效的。

3. 条件变量的使用：在生产者-消费者模式中，条件变量用于在生产者和消费者之间进行通信。当生产者向条件变量发送信号时，消费者会在等待中被唤醒，从而避免了在队列上进行显式的锁定。条件变量的使用确保了生产者和消费者之间的同步，而不需要显式的锁机制。

4. 队列的线程安全性：C++标准库中的queue默认不是线程安全的，但在你的代码中，task_queue是stEnv_t结构体的一部分，而stEnv_t是每个线程的独立副本。因此，每个线程对task_queue的操作都是线程安全的，不需要额外的锁机制。

然而，虽然在你的代码中没有显式上锁，但在多线程环境中，仍然需要确保每个线程对共享资源的访问是线程安全的。在上述代码中，这通过__thread关键字和stEnv_t结构体的独立副本实现。

总之，使用__thread关键字和条件变量，结合协程的特性，使得在生产者-消费者模式中可以避免显式上锁，从而提高了代码的效率和可读性。

5. 两个协程访问资源不需要加队列吗

在你的代码中，虽然两个协程（生产者和消费者）访问task_queue时没有显式地使用锁（如std::mutex），但这并不意味着没有进行资源保护。这里的关键在于__thread关键字和协程的特性。

• _THREAD关键字的作用

__thread关键字用于在多线程环境中为每个线程提供独立的变量副本。因此，当你在全局作用域中定义gCoEnvPerThread变量时，__thread关键字确保了每个线程都有自己独立的stEnv_t结构体副本，包括其中的task_queue。这意味着每个线程在访问task_queue时，都会访问自己独立的队列副本，而不是共享的全局队列。因此，不需要显式上锁，因为每个线程只会影响自己的队列副本。

• 协程的特性

协程是一种轻量级的线程切换机制，它允许在多个函数之间切换执行，而不需要创建和销毁线程。协程的上下文切换开销比线程要小得多，因此可以更频繁地进行切换。由于协程的特性，协程之间的通信通常不需要复杂的锁机制，因为协程的上下文切换是快速且高效的。

• 条件变量的使用

在生产者-消费者模式中，条件变量用于在生产者和消费者之间进行通信。当生产者向条件变量发送信号时，消费者会在等待中被唤醒，从而避免了在队列上进行显式的锁定。条件变量的使用确保了生产者和消费者之间的同步，而不需要显式的锁机制。

• 线程安全性

虽然在你的代码中没有显式上锁，但在多线程环境中，仍然需要确保每个线程对共享资源的访问是线程安全的。在上述代码中，这通过__thread关键字和stEnv_t结构体的独立副本实现。每个线程对task_queue的操作都是线程安全的，因为每个线程都有自己独立的stEnv_t结构体副本。

总之，使用__thread关键字和条件变量，结合协程的特性，使得在生产者-消费者模式中可以避免显式上锁，从而提高了代码的效率和可读性。然而，这并不意味着没有进行资源保护，而是通过__thread关键字和协程的特性实现了线程安全。

5. 参考

https://blog.csdn.net/weixin_43705457/article/details/106863859