microPython的源码解析之 modthread.c

MicroPython 是一种适用于微控制器和其他受限环境的 Python 编程语言的实现。它旨在提供与 Python 3 语言的紧密兼容，同时考虑到内存和计算资源的限制。MicroPython 库是这门语言的核心组成部分，提供了一系列的模块和函数，使得开发者能够在硬件上执行各种任务。
下面将通过系列文章,逐一解读microPython,以便让读者了解掌握microPython的整个核心逻辑.,以便读者可以透过这个Python的最小内核,掌握Python解析器的核心实现逻辑,学习世界上最优秀的源码设计之一.

microPython Python最小内核源码解析
这段代码是一个MicroPython线程模块的实现，它提供了线程创建、锁机制以及线程管理等功能。代码中定义了锁对象mp_type_thread_lock和线程模块mp_module_thread，以及相关的函数和方法。
通过这些功能，MicroPython可以在多线程环境中进行同步和并发操作，提高程序的执行效率。代码中的注释详细说明了每个函数和结构体的用途，有助于理解线程模块的工作原理。

#include <stdio.h>
#include <string.h>

// 导入MicroPython运行时环境和堆栈控制模块
#include "py/runtime.h"
#include "py/stackctrl.h"

#if MICROPY_PY_THREAD

// 导入MicroPython线程模块
#include "py/mpthread.h"

// 调试模式下打印调试信息
#if MICROPY_DEBUG_VERBOSE
#define DEBUG_PRINT (1)
#define DEBUG_printf DEBUG_printf
#else
#define DEBUG_PRINT (0)
#define DEBUG_printf(...) (void)0
#endif

/****************************************************************/
// 锁对象实现

// 定义锁对象类型
static const mp_obj_type_t mp_type_thread_lock;

// 定义锁对象结构体
typedef struct _mp_obj_thread_lock_t {
   
    mp_obj_base_t base;          // 继承自基础对象
    mp_thread_mutex_t mutex;     // 互斥锁，用于线程同步
    volatile bool locked;        // 标记锁是否被占用
} mp_obj_thread_lock_t;

// 创建新的锁对象
static mp_obj_thread_lock_t *mp_obj_new_thread_lock(void) {
   
    mp_obj_thread_lock_t *self = mp_obj_malloc(mp_obj_thread_lock_t, &mp_type_thread_lock);
    mp_thread_mutex_init(&self->mutex); // 初始化互斥锁
    self->locked = false;            // 默认锁未被占用
    return self;
}

// 尝试获取锁
static mp_obj_t thread_lock_acquire(size_t n_args, const mp_obj_t *args) {
   
    mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(args[0]);
    bool wait = true;                // 默认等待锁释放
    if (n_args > 1) {
   
        wait = mp_obj_get_int(args[1]); // 获取等待参数
    }
    MP_THREAD_GIL_EXIT();             // 退出全局解释器锁
    int ret = mp_thread_mutex_lock(&self->mutex, wait); // 尝试获取互斥锁
    MP_THREAD_GIL_ENTER();            // 重新进入全局解释器锁
    if (ret == 0) {
   
        return mp_const_false;       // 获取锁失败
    } else if (ret == 1) {
   
        self->locked = true;         // 标记锁已被占用
        return mp_const_true;       // 获取锁成功
    } else {
   
        mp_raise_OSError(-ret);      // 抛出操作系统错误
    }
}
// 定义获取锁的函数对象
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(thread_lock_acquire_obj, 1, 3, thread_lock_acquire);

// 释放锁
static mp_obj_t thread_lock_release(mp_obj_t self_in) {
   
    mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(self_in);
    if (!self->locked) {
   
        mp_raise_msg(&mp_type_RuntimeError, NULL); // 如果锁未被占用，抛出运行时错误
    }
    self->locked = false;             // 标记锁为未被占用
    MP_THREAD_GIL_EXIT();             // 退出全局解释器锁
    mp_thread_mutex_unlock(&self->mutex); // 释放互斥锁
    MP_THREAD_GIL_ENTER();            // 重新进入全局解释器锁
    return mp_const_none;           // 返回None
}
// 定义释放锁的函数对象
static MP_DEFINE_CONST_FUN_OBJ_1(thread_lock_release_obj, thread_lock_release);

// 查询锁是否被占用
static mp_obj_t thread_lock_locked(mp_obj_t self_in) {
   
    mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(self_in);
    return mp_obj_new_bool(self->locked); // 返回锁的占用状态
}
// 定义查询锁状态的函数对象
static MP_DEFINE_CONST_FUN_OBJ_1(thread_lock_locked_obj, thread_lock_locked);

// 线程退出时自动释放锁
static mp_obj_t thread_lock___exit__(size_t n_args, const mp_obj_t *args) {
   
    (void)n_args; // 未使用的参数
    return thread_lock_release(args[0]); // 调用释放锁的函数
}
// 定义线程退出时的函数对象
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(thread_lock___exit___obj, 4, 4, thread_lock___exit__);

// 定义锁对象的本地方法字典
static const mp_rom_map_elem_t thread_lock_locals_dict_table[] = {
   
    {
    MP_ROM_QSTR(MP_QSTR_acquire), MP_ROM_PTR(&thread_lock_acquire_obj) },
    {
    MP_ROM_QSTR(MP_QSTR_release), MP_ROM_PTR(&thread_lock_release_obj) },
    {
    MP_ROM_QSTR(MP_QSTR_locked), MP_ROM_PTR(&thread_lock_locked_obj) },
    {
    MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&thread_lock_acquire_obj) },
    {
    MP_ROM_QSTR(MP_QSTR___exit__