/*** poller響應(yīng)timerfd的到時事件，并處理所有到時的定時任務(wù) ***/
static void __poller_handle_timeout(const struct __poller_node *time_node, poller_t *poller)                           
{                                                                               
    ...

    // 鎖里，把list與rbtree上時間已到的節(jié)點都從數(shù)據(jù)結(jié)構(gòu)里刪除，臨時放到一個局部變量上                                        
    list_for_each_safe(pos, tmp, &poller->timeo_list)                           
    {
       ...
       node->removed = 1; // 標(biāo)志位：【removed】
       ...
    }

    if (poller->tree_first)                                                     
    { ... }  

    // 鎖外，設(shè)置state和error，并回調(diào)Task的handle()函數(shù)
    while (!list_empty(&timeo_list))                                            
    {                                                                           
        node = list_entry(timeo_list.next, struct __poller_node, list);         
        list_del(&node->list);                                                  

        node->error = ETIMEDOUT;                                                
        node->state = PR_ST_ERROR;                                              
        free(node->res);                                                        
        poller->cb((struct poller_result *)node, poller->ctx);                  
    }                                                                           
}

/*** 取消一個定時任務(wù)時，從poller刪除它 ***/
int poller_del_timer(void *timer, poller_t *poller)
{
    ...
    // 鎖內(nèi)：如果這個標(biāo)志位還是0，表示stop還沒把它拿走，這里就可以去刪除這個timer
    if (!node->removed)
    {
        node->removed = 1; // 可以讓cancel和stop互斥，保證只調(diào)一次

        if (node->in_rbtree) // 從定時器的數(shù)據(jù)結(jié)構(gòu)中刪掉
            __poller_tree_erase(node, poller);
        else
            list_del(&node->list);
        node->error = 0;                                                        
        node->state = PR_ST_DELETED;                                                
        stopped = poller->stopped;                                                  
        if (!stopped) // 標(biāo)志位【stopped】，如果當(dāng)時沒有進程退出，把timer事件交出去處理
            write(poller->pipe_wr, &node, sizeof (void *));
    }
    ...

    // 鎖外：標(biāo)志位【stopped】如果進程要退出了，立刻處理timer事件的handle
    if (stopped)
        poller->cb((struct poller_result *)node, poller->ctx);

    return -!node;
}

/*** 處理定時器到期，由poller調(diào)用 ***/
void __WFNamedTimerTask::handle(int state, int error)    
{    
    if (node_.task) // 由于不想先加鎖再處理，所以先判斷任務(wù)沒有被cancel處理過
    {
        std::lock_guard<std::mutex> lock(__timer_map.mutex_);    
        if (node_.task) // 鎖內(nèi)再檢查一下，入門技能
        {
            timers_->del(&node_, &__timer_map.root_); // 從map中刪除
            node_.task = NULL; // 標(biāo)志位：表示任務(wù)生命周期結(jié)束了
        }    
    }

    mutex_.lock();   // 這里是為了等待dispatch流程保證exchange已經(jīng)結(jié)束，
    mutex_.unlock(); // 否則資源被釋放就不能訪問成員變量了。也是非常常用的技巧！
    this->__WFTimerTask::handle(state, error); // 里邊會釋放資源，并發(fā)起任務(wù)流下一個任務(wù)
}

void __NamedTimerMap::cancel(const std::string& name, size_t max)               
{
    ...
    // 鎖內(nèi)，拿出命名為name的timer隊列
    timers = __get_object_list<TimerList>(name, &root_, false);                 
    if (timers)
    {
        do
        {
            if (max == 0) // 從map中刪除最多max個
                return;

            // 從該名字對應(yīng)的隊列中刪除該timer
            node = list_entry(timers->head.next, struct __timer_node, list);    
            list_del(&node->list);

            // 標(biāo)識位：exchange。如果是第二次exchange，會調(diào)到task自身的cancel()從poller中刪掉它
            if (node->task->flag_.exchange(true))
                node->task->cancel();

            // 標(biāo)志位：表示生命周期正確結(jié)束，資源已經(jīng)被回收，否則timeout流程或析構(gòu)函數(shù)需要做回收
            node->task = NULL;                                                  
            max--;                                                              
        } while (!timers->empty());                                             

        rb_erase(&timers->rb, &root_);
        delete timers;
    }
}

/*** 由任務(wù)流發(fā)起、或者用戶手動start起來 ***/
void __WFNamedTimerTask::dispatch()
{    
    int ret;    

    mutex_.lock();    
    ret = this->scheduler->sleep(this); // 先把定時任務(wù)交給poller
    if (ret >= 0 && flag_.exchange(true)) // exchange一下。如果是第二個調(diào)用exchange的人，會拿到true
        this->cancel(); // 說明發(fā)起之前已經(jīng)有人cancel過了，立刻從poller中刪除即可

    mutex_.unlock();    
    if (ret < 0)    
        this->handle(SS_STATE_ERROR, errno);
}

/*** 命名定時任務(wù)的析構(gòu)函數(shù)，異步任務(wù)需要注意處理各種情況的資源回收 ***/
virtual ~__WFNamedTimerTask()
{
    if (node_.task) // 標(biāo)志位：如果沒有置空，說明任務(wù)沒有發(fā)起過。需要從全局map中刪掉這個timer
    {
         std::lock_guard<std::mutex> lock(__timer_map.mutex_);
         if (node_.task) // 鎖內(nèi)再檢查一次
             timers_->del(&node_, &__timer_map.root_);
    }
}

int main()
{
    WFHttpServer server([](WFHttpTask * task)
    {
        task->get_resp()->append_output_body("<html>will response after 1s</html>");
        auto timer = WFTaskFactory::create_timer_task(1, 0, nullptr);
        series_of(task)->push_back(timer);
    }); 

    if (server.start(1412) == 0)
    {   
        getchar();
        server.stop();
    }
    return 0;
}