private:
    uint64_t m_id = 0;          // 协程ID
    uint32_t m_stacksize = 0;   // 协程栈大小
    State m_state = READY;      // 协程状态
    ucontext_t m_ctx;           // 协程上下文
    void *m_stack;              // 协程栈地址
    std::function<void()> m_cb; // 协程函数入口
    bool m_runInScheduler;      // 本协程是否参与调度器调度

// 线程局部变量，代表当前线程正在运行的协程
static thread_local Fiber *t_fiber = nullptr;

// 线程局部变量，当前线程的主协程，切换到这个协程相当于切换到了主线程中运行，智能指针
static thread_local Fiber::ptr t_thread_fiber = nullptr;

typedef struct ucontext {
	struct ucontext *uc_link; 		// 下一个上下文，如果为NULL，执行完后线程退出
	sigset_t         uc_sigmask;	// 阻塞信号集合
	stack_t          uc_stack;		// 栈空间
	mcontext_t       uc_mcontext;	// 保存的上下文的特定机器表示，包括调用线程的特定寄存器等，对程序员透明
	// ... 其他成员
} ucontext_t;

int getcontext(ucontext_t *ucp);
// 将当前运行的上下文保存在ucp中
// 执行成功返回0

void makecontext(ucontext_t *ucp, void (*func)(), int argc, ...);
// 创建一个上下文
// 注意，该函数的第一个参数需要是从getcontext函数中获得上下文，内部对其修改
// 这意味着，makecontext函数需要和getcontext函数一起调用，如果有必要需要手动为其开辟栈空间
// 创建上下文之后可以使用setcontext或者swapcontext进行上下文切换

int setcontext(const ucontext_t *ucp);
// 设置当前的上下文为ucp
// 如果调用成功则不会返回，直接执行新的上下文
// 调用失败则返回-1，并设置对应的erron

int swapcontext(ucontext_t *oucp, ucontext_t *ucp);
// 保存当前上下文到oucp中，然后切换到上下文ucp中
// 如果调用成功则不会返回，直接执行新的上下文
// 调用失败则返回-1，并设置对应的erron

// 构造函数
Fiber(std::function<void()> cb, size_t stack_size = 0, bool run_in_scheduler = true);
// 第一个参数是回调函数也就是任务函数

// 重置协程状态和入口函数，复用栈空间，不重新创建栈
void reset(std::function<void>()> cb);
// 该函数比较简单，核心操作就两步
// 一，使用getcontext和makecontext函数创建新的上下文
// 二，将协程状态设置为就绪(READY)

// 将当前协程切换到执行状态
void resume();
// 首先判断当前协程的类型
// 一、当前协程是任务协程，也就是说他参与调度，同时也说明正在运行的协程是调度协程，那么交换调度协程的上下文与当前协程上下文即可
// 二、当前协程不是任务协程，也就是不参与调度，同时也说明正在运行的协程是线程主协程，那么交换主协程和当前协程即可
// 规律：只有线程主协程才会调用调度协程的resume方法，而只用调度协程才会去调用任务协程的resume方法。

// 当前线程让出执行权
void yield();
// 具体操作其实和resume函数很像
// 一、当前协程是任务协程，即自己参与调度，那么将交换当前协程与调度协程的上下文即可
// 二、当前协程是调度协程，即自己不参与调度，那么交换当前协程与线程主协程即可
// 规律：协程自己内部才会调用yield方法，然后进入就被调度的状态

// 如何使用协程
// 一、创建一个协程，对于有参函数可以使用std::bind进行参数绑定
// 二、只要协程没有正式开始执行，可以使用reset函数进行重设
// 三、调用协程的resume方法开始运行协程
// 四、调用协程yield方法临时终止，后续可以继续使用yield方法继续执行

private:
    std::string m_name;                                 // 协程调度器名称
    MutexType m_mutex;                                  // 互斥锁
    std::vector<std::shared_ptr<std::thread>> m_threads;// 线程池
    std::list<ScheduleTask> m_tasks;                    // 任务队列
    std::vector<std::thread::id> m_threadIds;           // 记录工作线程的id
    size_t m_threadCount = 0;                           // 工作线程的数量，不包含 use_caller 的主线程
    std::atomic<size_t> m_activeThreadCount {0};        // 活跃的线程数量
    std::atomic<size_t> m_idleThreadCount {0};          // idle线程数量

    bool m_useCaller;                                   // 是否直接利用主线程进行协程工作
    Fiber::ptr m_rootFiber;                             // m_useCaller为true时，调度器所在线程的调度协程
    std::thread::id m_rootThread = std::thread::id(-1); // m_userCaller为true时，调度器所在线程的ID

    bool m_stopping = false;                            // 调度器是否正在停止

// 构造函数
Scheduler(size_t threads = 1, bool use_caller = true, const std::string &name = "scheduler");
// threads 表示真正进行协程工作的线程数量，如果主线程也参与协程工作那么只需要额外启动threads-1个线程
// use_caller 表示主线程是否参与协程工作任务
// 如果use_caller==true，那么main函数将会存在三种协程，一种是主协程，主要是创建调度器，向任务队列加入任务的工作
// 第二种是主线程的调度协程，第三种是主线程的工作协程，有若干个
// 如果主线程参与执行协程工作，那么需要构造函数中会在主线程中创建主线程的调度协程，并将threads的值减1

// 添加调度任务
template <typename FiberOrcb>
void schedule(FiberOrcb fc, std::thread::id thread = std::thread::id(-1));
// fc 是一个可调用的对象，可以是协程也可以是函数
// thread 是期望该协程工作在哪一个线程中
// 其内部工作流程比较简单
// 首先将互斥锁上锁，然后任务加入到任务队列中即可

// 协程调度函数
void run();
// 每个线程的调度协程会执行该函数
// 该函数开始部分，首先设置好线程局部变量t_scheduler_fiber，该变量指向了每个线程的调度协程
// 接下来是一个死循环，每次循环尝试从任务队列中取出一个任务，如果该任务指定了线程且不是当前线程，那么继续查找下一个任务
// 如果该任务是一个协程，那么执行，如果是一个函数，那么将他封装成协程然后执行
// 如果任务队列已经没有任务可取了，那么会转而执行idle协程用于等待任务 --> 这里idle协程的实现是什么也不做

// 空闲调度函数
virtual void idle();
// 无任务执行时线程会执行idle协程，idle协程内部执行该函数
// 在此调度器中idle什么事也不做，直接执行yield
// 该函数是虚函数，此调度器的子类可以重写该方法

// 通知协程调度器有任务
virtual void tickle();
// 该函数什么也没做

// 启动调度器
void start();
// 前面提到过我们可以使用多线程来同时执行更多的协程，因此启动调度器的作用就是创建这些线程
// 线程的入口函数Scheduler::run，其实也就是创建了每个线程的调度协程
// 如果确实开启了多线程，那么执行了start函数之后就会直接开始协程调度工作

// 停止调度器
void stop();
// 停止调度器意味着将不再允许继续添加任务了，但是未执行的任务还是会继续执行
// 前面提到过主线程也可以参与协程任务执行，而主线程为了能够保证调度器的正常工作，只有在停止调度器后才会执行协程任务
// 不难推断出，如果不开启多线程，那么只有在停止协程调度器之后才会开始真正的协程调度

private:
    bool m_recurring = false;                                           // 是否循环
    std::chrono::milliseconds m_ms = std::chrono::milliseconds(0);      // 多久之后执行，相对于创建定时器时间戳的相对时间
    std::chrono::milliseconds m_next = std::chrono::milliseconds(0);    // 精确的执行绝对时间 == 创建时间戳 + m_ms      
    std::function<void()> m_cb;                                         // 回调函数
    TimerManager *m_manager = nullptr;                                  // 定时器管理器

private:
    // 私有构造函数
    Timer(std::chrono::milliseconds ms, std::function<void()> cb, bool recurring, TimerManager *manager);
    Timer(std::chrono::milliseconds next);

public:
    // 取消定时器
    bool cancel();
    // 刷新设置定时器执行时间
    bool refresh();
    // 重置定时器的时间
    bool reset(std::chrono::milliseconds ms, bool from_now);
private:
    // 定时器比较仿函数，按执行时间排序
    struct Comparator
    {
        bool operator()(const Timer::ptr &lhs, const Timer::ptr &rhs) const;
    };

// 使用 std::shared_mutex 来模拟读写锁
typedef std::shared_mutex RWMutexType; // 读写锁
typedef std::unique_lock<std::shared_mutex> WriteLock;
typedef std::shared_lock<std::shared_mutex> ReadLock;

private:
    // Mutex
    RWMutexType m_mutex;                                                        // 读写锁
    std::set<Timer::ptr, Timer::Comparator> m_timers;                           // 定时器集合，内部保存定时器的智能指针
    bool m_tickled = false;                                                     // 是否触发 onTimerInsertedAtFront
    std::chrono::milliseconds m_previouseTime = std::chrono::milliseconds(0);   // 上次执行时间

public:
    // 构造函数
    TimerManager(); // 默认构造函数
    ~TimerManager(); // 析构函数
    // 添加定时器
    Timer::ptr addTimer(std::chrono::milliseconds ms, std::function<void()> cb, bool recurring = false);
    // 添加条件定时器
    Timer::ptr addConditionTimer(std::chrono::milliseconds ms, std::function<void()> cb, 
                                    std::weak_ptr<void> weak_cond, bool recurring = false);
    // 到最近一个定时器执行的时间间隔（毫秒）
    std::chrono::milliseconds getNextTimer();
    // 获取需要执行的过期的定时器的回调函数列表
    void listExpiredCb(std::vector<std::function<void()>> &cbs);
    // 是否有定时器
    bool hasTimer();
protected:
    // 有新的定时器插入到定时器的首部时，执行该函数
    virtual void onTimerInsertedAtFront() = 0; // 纯虚函数
    // 将定时器添加到管理器中
    void addTimer(Timer::ptr val, WriteLock &lock);
private:
    // 检测服务器时间是否被调后了，该函数实现比较粗糙
    bool detectClockRollover(std::chrono::milliseconds now_ms);

enum Event{
	NONE = 0x0, // 无事件 
	READ = 0x1, // 读事件 EPOLLIN
	WRITE = 0x4 // 写事件 EPOLLOUT
};

private:
    // socket fd上下文类
    // 每一个socket fd都对应一个FdContext，包括fd值，fd上的事件以及fd的读写事件上下文
    struct FdContext
    {
        typedef std::mutex MutexType; 
        // 事件上下文
        // fd的每个事件都有一个事件上下文，保存这个事件的回调函数以及执行回调函数的调度器
        struct EventContext
        {
            Scheduler *scheduler = nullptr;     // 执行事件回调的调度器
            Fiber::ptr fiber;                   // 事件回调协程
            std::function<void()> cb;           // 事件回调函数
        };
        // 获取事件上下文
        EventContext &getEventContext(Event event);
        // 重置事件上下文
        void resetEventContext(EventContext &ctx);
        // 触发事件
        void triggerEvent(Event event);

        EventContext read;          // 读事件上下文
        EventContext write;         // 写事件上下文
        int fd = 0;                 // 事件
        Event events = NONE;        // fd关心什么时间
        MutexType mtx;              // 互斥锁
    };

void triggerEvent(Event event);
// 这里的设计思路是注册的IO事件是一次性的，事件触发之后就会被删除，如果想持续关注某个fd的读写事件，那么需要在触发之后重新添加
// 重新添加的操作可以考虑实现在回调函数中

private:
    int m_epfd = 0;                                 // epoll 文件句柄
    int m_tickleFds[2];                             // pipe文件句柄，fd[0]读端口，fd[1]写端口，
													// 用于在定时器触发时及时退出epoll_wait
    std::atomic<size_t> m_pendingEventCount {0};    // 当前等待执行的IO事件数量
    RWMutexType m_mutex;                            // IOManager的mutex
    std::vector<FdContext *> m_fdContexts;          // socket事件上下文容器

// 构造函数
IOManager(size_t threads = 1, bool use_caller = true, const std::string &name = "IOManager");
// IOManager继承于Scheduler和TimerManager，TimerManager只有默认构造函数，而IOManager构造时不依赖额外参数
// 因此此构造函数的参数全部用来构造Scheduler
// IOManager构造工作主要是：
// 一、初始化epoll资源获取epoll文件描述符
// 二、创建管道，将管道读端口加入epoll监听队列中，并设置管道为非阻塞，对应读端口为ET边缘触发
// 三、预设置FdContexts容器长度，默认为32
// 四、调用Scheduler::start()方法，启动调度器，这样如果采用多线程，就开始可以直接执行任务了

// 析构函数
~IOManager();
// 析构函数的工作就比较简单了
// 一、调用Scheduler::stop()方法来结束协程调度，该函数会阻塞直到所有协程执行完毕
//    而且当我们只开启一个线程时，调用stop方法后才会正式开始协程调度
// 二、释放文件句柄，包括epoll文件句柄，管道资源
// 三、释放所有FdContext

// 添加事件
int addEvent(int fd, Event event, std::function<void()> cb = nullptr);
// 前面说到一个文件事件就是一个三元组，对应添加事件的三个参数
// 添加的事件都保存在IOManager::m_fdContexts中，这是一个vector容器，索引对应着fd，
// 因此增删改查事件时必须先判断容器中是否存在这个元素
// 一、添加事件时，如果fd超过容器长度，则需要容器进行扩容，这也是处理fd的基本操作了
// 二、使用epoll_ctl将新的事件加入epoll_wait队列中，使用epoll_event的私有指针存储FdContext的位置
// 三、更新待执行IO事件数量，加一
// 四、将对应事件的事件上下文相关数据进行赋值，包括回调函数，协程调度器指针

// 删除事件
bool delEvent(int fd, Event event);
// 删除事件只需要对应的fd和事件类型即可，本质上是从epoll等待队列中移除该事件
// 一、首先根据传入的fd找到对应的FdContext，如果不存在直接返回
// 二、判断删除的事件类型是否存在，不存在直接返回
// 三、使用epoll_ctl删除指定类型事件
// 四、更新待执行IO事件数量，减一
// 五、重置fd对应事件类型的上下文，释放一些资源

// 取消事件
bool cancelEvent(int fd, Event event);
// 将事件从epoll等待队列中移除，但是不重置事件上下文，而且取消该事件时自动调用一次
// 一、首先根据传入的fd找到对应的FdContext，如果不存在直接返回
// 二、判断取消的事件类型是否存在，不存在直接返回
// 三、使用epoll_ctl删除指定类型事件
// 四、更新待执行IO事件数量，减一
// 五、主动调用该事件，即调用IOManager::FdContext::triggerEvent方法

// 取消所有事件
bool cancalAll(int fd);
// 取消对应fd中的所有事件，操作和cancelEvent很像，取消的事件都会被手动执行一次

// 返回当前的IOManager
IOManager *IOManager::GetThis()
{ // 动态类型检查
    return dynamic_cast<IOManager *>(Scheduler::GetThis());
}
// 实际上只有在协程调度才会用到，因此这里采用动态类型转换

// 通知调度器有任务要调度
void tickle() override;
// 主要是让调度协程从idle函数中退出
// 主要使用在定时器管理器在最前方插入新定时器时需要退出epoll_wait从而防止超时，同时调用Scheduler::schedule也会触发该函数
// 一、首先检查是否有IO调度任务，其实也就是判断待执行IO事件数量，如果有事件待执行，那么直接退出，因为此时idle也不会执行
// 二、如果此时确实在idle中，那么想管道中写入数据，这样idle中的epoll_wait就会收到信息进而直接返回，然后idle就会结束执行

// 判断条件是Scheduler::stopping()外加IOManager的m_pendingEventCount为0，表示没有IO事件可调度了
bool stopping() override;
// 判断是否可以停止，同时获取最近一个定时器的超时时间
bool stopping(std::chrono::milliseconds &timeout);
// 判断的条件是timeout之后没有定时器了，并且此时没有待执行IO事件，同时调度器也可以停止了

void idle() override;
// 每一个线程的调度协程在无任务时会转而阻塞在idle协程上，idle阻塞的来源是epoll_wait函数
// idle主要关心两类事件
// 一种是调度器主动添加事件Scheduler::schedule方法，或者定时器调度器在最前方插入了一个定时器，这些事件回通过tickle来让其打断idle的阻塞过程
// 第二种是当前epoll关注的事件是否有触发，如果触发则调用相应的回调函数
// idle协程可能会反复执行，因此内部是一个死循环
// 一、首先判断IOManager是否停止了，如果停止那么idle协程也可以直接结束了
// 二、获取最近一次定时器超时的时间间隔，并和默认的5秒等待时间进行比较，取最小值
//		epoll_wait每次默认等待5秒，但是如果有定时器在这5秒中触发，则需要提前退出
// 三、epoll_wait退出后我们尝试获取超时定时器执行列表，并将他们仿佛协程调度中
// 四、接下才会处理epoll_wait返回的文件描述符对应的事件
//		对于触发的文件描述符，通过对应epoll_event.data.ptr即可获取对应的EventContext。
//		如果epoll返回错误，那么将执行对应fd的所有事件(如果存在)
//		执行的事件将会从epoll关注队列中删除，将触发的事件对应回调函数加入协程调度中
// 五、处理完事件后，idle退出，因为他也只是将协程添加到调度中去，所以自己yield后去执行调度的协程的任务

void onTimerInsertedAtFront() override;
// 定时器管理器中插入最近时间的定时器后需要及时停止idle的阻塞，防止定时任务不及时执行，内部就是调用了tickle函数

private:
    bool m_isInit       : 1;                    // 是否初始化
    bool m_isSocket     : 1;                    // 是否为socket
    bool m_sysNoBlock   : 1;                    // 是否hook非阻塞
    bool m_userNoBlock  : 1;                    // 是否用户设置非阻塞
    bool m_isClosed     : 1;                    // 是否关闭
    int m_fd;                                   // 文件句柄
    std::chrono::milliseconds m_recvTimeout;    // 读超时时间毫秒
    std::chrono::milliseconds m_sendTimeout;    // 写超时时间毫秒

// 文件句柄管理类
class FdManager
{
public:
    typedef std::shared_mutex RWMutex; // 读写锁
    typedef std::unique_lock<std::shared_mutex> WriteLock;
    typedef std::shared_lock<std::shared_mutex> ReadLock;
    // 无参构造函数
    FdManager();
    // 获取创建文件句柄类FdCtx::ptr
    FdCtx::ptr get(int fd, bool auto_create = false);
    // 删除文件句柄类
    void del(int fd);
private:
    RWMutex m_mutex;                    // 读写锁
    std::vector<FdCtx::ptr> m_datas;    // 文件句柄集合
};
// 文件句柄管理类单例对象
typedef Singleton<FdManager> FdMgr;

static thread_local bool t_hook_enable = false; // 每一个线程是否开启hook

template <typename OriginFun, typename... Args>
static ssize_t do_io(int fd, OriginFun fun, const char *hook_fun_name, uint32_t event, int timeout_so, Args &&... args);
// 一、不启用hook或者FdManager获取对应FdCtx失败，直接执行原来的系统函数，返回
// 二、此时fd已经被FdManager设置为非阻塞了，因此进行非阻塞的系统调用，调用成功直接返回
// 三、系统调用返回失败并且errno == EAGAIN，表示资源暂时不可用，这种情况需要过段时间重试，其他情况直接返回错误即可
// 四、接下来判断是否传入了有效的超时时间，如果有效，则设置一个条件超时定时器，内部表示超时时间时触发一次event事件
// 五、添加event类型事件，回调函数是当前协程
// 六、yield 让出执行权
// 七、再次被调度，这里有两种情况一是超时触发，而是epoll检测可读/写，如果是因为超时触发，则函数直接返回-1，如果是可读/写触发，则回到二执行

name_f = (name_fun)dlsym(RTLD_NEXT, #name);