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

文章目录

- 1. CoRoutineEnv_t结构体用于管理协程环境
3 Liboc协程生产者消费者例子
4 Liboc协程生产者消费者，为什么队列不需要上锁？
5. 两个协程访问资源不需要加队列吗
5. 参考

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协程生产者消费者，为什么队列不需要上锁？

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

线程局部存储（Thread Local Storage, TLS）：在你的代码中，使用了__thread关键字来确保每个线程都有自己独立的gCoEnvPerThread变量副本。这意味着每个线程在访问stEnv_t结构体中的task_queue时，都会访问自己独立的队列副本，而不是共享的全局队列。因此，不需要显式上锁，因为每个线程只会影响自己的队列副本。
协程的特性：协程（co-routine）是一种轻量级的线程切换机制，它允许在多个函数之间切换执行，而不需要创建和销毁线程。协程的上下文切换开销比线程要小得多，因此可以更频繁地进行切换。由于协程的特性，协程之间的通信通常不需要复杂的锁机制，因为协程的上下文切换是快速且高效的。
条件变量的使用：在生产者-消费者模式中，条件变量用于在生产者和消费者之间进行通信。当生产者向条件变量发送信号时，消费者会在等待中被唤醒，从而避免了在队列上进行显式的锁定。条件变量的使用确保了生产者和消费者之间的同步，而不需要显式的锁机制。
队列的线程安全性：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时，都会访问自己独立的队列副本，而不是共享的全局队列。因此，不需要显式上锁，因为每个线程只会影响自己的队列副本。