想必大家在初次接觸多執行緒或多程序時一定會感覺這是多麼的神奇!一個程式居然可以“同時”執行好多工作，此時你一定有一探其究竟的想法吧？可是無奈，這些都是核心中十分複雜的程式碼。對於初入計算機大門的我們，去看那些東西，的確有些困難。但是不用灰心，本篇博文我將為大家介紹一個由我自己實現的簡單執行緒，程式碼也就100多行，程式還很簡陋，但是我感覺這有助於我們對程序或執行緒的理解

1.設計思路

要實現執行緒，那麼就先得有個簡單的設計思路，具體有如下幾步

.實現能夠儲存當前上下文的功能函式，並實現能夠將當前程式執行切向某個函式的功能函式。如果自己要做到這點，一定會很麻煩，也不簡
單，好在ucontext.h標頭檔案中為我們提供了該類功能函式的API
.如何進行執行緒排程？我採用了傳統的時間片輪訓，設定一個定時器，當定時器觸發時，將會觸發訊號處
理函式(即排程函式)
 

我想能夠實現上述倆點，那麼實現執行緒這項工作剩下的也都是些細枝末葉了

2.前期知識準備

要完成1中的第一點，我們只需要學習一下ucontext.h為我們提供的幾個API介面的使用即可
具體如下

1.獲取當前執行程式上下文的API

int getcontext(ucontext_t *ucp);
//失敗返回-1

ucontext_t結構體定義如下

 typedef struct ucontext {
               struct ucontext *uc_link;
               sigset_t         uc_sigmask;
               stack_t          uc_stack;
               mcontext_t       uc_mcontext;
               ...
 

           } ucontext_t;

該介面可獲取當前程式上下文並將其儲存到ucp中

2.將當前程式切換到某個上下文處的API

 int setcontext(const ucontext_t *ucp);

該API會將當前程式所執行的地方切換至ucp指向的上下文處

具體例項如下

#include <stdio.h>
#include <ucontext.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
  ucontext_t context;

  //獲取當前程式上下文
 

  getcontext(&context);
  puts("Hello world");
  sleep(1);
  //將程式切換至context指向的上下文處
  setcontext(&context);
  return 0;
}

該程式執行結果如下

你可能會驚訝的發現這雜麼成了一個無線迴圈了!其實只要你理解了上面介紹的倆個API這一點都不奇怪
上述程式碼中我們先用getcontext獲取其所在位置的程式上下文，之後程式往下執行，當執行到setcontext時，我們上面以介紹過他的功能，其會將當前執行程式的位置挪到我們之前儲存下來的程式上下文context的內容，所以執行完此條語句後程序又會回到getcontext所在的語句處，也因此這段程式碼成了一個無限迴圈了

3.swapcontext

int swapcontext(ucontext_t *oucp, const ucontext_t *ucp);

該介面融合了上述介紹的1,2倆個介面的功能
我們可以將其功能理解為
首先執行getcontext(oucp);
然後執行setcontext(ucp);

4.將當前上下文入口改為某個函式入口的API

void makecontext(ucontext_t *ucp, void (*func)(), int argc, ...);

將API會將當前上下文ucp入口切換為func函式的額入口，及如果我們執行了setcontext(ucp)後，程式會去執行func函式
具體例項如下

   #include <stdio.h>
   #include <ucontext.h>
  #include <unistd.h>

  void fun(void)
  {
      printf("hello,world\n");
  }

  int main(int argc, char *argv[]) {
    ucontext_t context;
    char stack[1024];                                                                                                                         
    getcontext(&context);
    context.uc_stack.ss_sp = stack;
    context.uc_stack.ss_size = 1024;
    makecontext(&context,fun,0);
    setcontext(&context);
    return 0;
  }

程式執行結果為

5.定時訊號的使用

關於定時訊號的使用非常簡單，我就不做太多介紹了
具體例項如下

   #include <stdio.h>
   #include <unistd.h>
  #include <signal.h>
  #include <sys/time.h>
  #include <functional>

  void print(int n)
  {
      printf("%s\n","hello,world");
  }

  int main(void)
  {
      int res = 0;
      struct itimerval tick;

      signal(SIGALRM,print);

      tick.it_value.tv_sec = 0;   //定時延時時間
      tick.it_value.tv_usec = 1;  //延時之後每多少長時間觸發一次定時事件

      tick.it_interval.tv_sec = 0;
      tick.it_interval.tv_usec = 100000;

      res = setitimer(ITIMER_REAL,&tick,NULL);                                                                                                
      if(res)
      {
          printf("set timer failed!!!\n");
      }


      while(1)
      {
          pause();
      }


      return 0;
  }

執行結果如下

3.開始實現自己的執行緒

我用C++11來開發這個小程式

執行緒類的標頭檔案定義如下

 #pragma once

#include <functional>
#include <ucontext.h>
#include <map>
#include <memory>
#include <assert.h>
#include <stdio.h>

namespace mythread
{
    class Mythread
    {
        public:
            Mythread(int stackSize = 10240);
            ~Mythread();
            void start(void);   //開始執行執行緒類物件

            template <typename threadCallback,typename ...Args>
            void newThread(threadCallback cb,Args ...args)  //建立新執行緒
            {
                std::unique_ptr<ucontext_t> threadContext(new ucontext_t);

                assert(getcontext(threadContext.get()) != -1);  //獲取當前上下文

                //設定當前上下文資訊    
                threadContext->uc_stack.ss_sp = new char[stackSize_];
                threadContext->uc_stack.ss_size = stackSize_;
                threadContext->uc_link = 0;
                threadContext->uc_flags = 0;
                assert(threadContext->uc_stack.ss_sp != NULL);

                //將引數cb切換為當前上下文的入口函式
                makecontext(threadContext.get(),cb,sizeof...(args),args...);
                //將當前上下文插入map之中
                threadMap_.insert(std::pair<int,std::unique_ptr<ucontext_t>>(makeThreadId(),std::move(threadContext)));
            }

            void destroyThread(int id);  //銷燬某個執行緒

        private:
            static void threadSchedule(int n); //執行緒排程函式
            int makeThreadId(void);     //生成一個執行緒id
            static std::map<int,std::unique_ptr<ucontext_t>> threadMap_;  //儲存執行緒id及其對應的執行緒上下文內容
            static int current_;                       //儲存當前執行緒id
            int stackSize_;             //每個執行緒的棧空間的大小
            int maxThreadNumber_;               //最大可建立執行緒數
    };
}

該類的設計具體為

.用一個map類的靜態變數threadMap_來儲存每個我們通過newThread介面建立的執行緒的執行緒id以及對應的執行緒執行的上下文
.current_用來儲存我們當前所執行的執行緒的執行緒id
.makeThreadId函式用來生成一個執行緒id給我們新建立的執行緒使用
.threadSchedule用來排程各個執行緒的執行
.newThread介面是可以供外部呼叫的介面，用來建立一個執行緒
.start介面用來啟動定時器，以及通過定時訊號來呼叫上述排程執行緒的threadSchedule函式

該類的具體實現如下

#include <ucontext.h>
#include <signal.h>
#include "coroutine.h"
#include <assert.h>
#include <sys/time.h>
#include <signal.h>
#include <functional>
#include <memory>
#include <stdio.h>

using namespace mythread;

std::map<int,std::unique_ptr<ucontext_t>> Mythread::threadMap_;
int Mythread::current_ = 1;


Mythread::Mythread(int stackSize)
    :stackSize_(stackSize)
{

}

Mythread::~Mythread()
{
    for(auto &t : threadMap_)
    {
        free(t.second->uc_stack.ss_sp);   
    }
    threadMap_.clear(); //將map中的內容清空   
}

void Mythread::start(void)
{
    std::unique_ptr<ucontext_t> mainContextPtr(new ucontext_t);
    threadMap_.insert(std::pair<int,std::unique_ptr<ucontext_t>>(1,std::move(mainContextPtr)));//將主執行緒加入到map中

    signal(SIGALRM,threadSchedule);

    struct itimerval tick;
    tick.it_value.tv_sec = 0;   //無定時器延時
    tick.it_value.tv_usec = 1;

    tick.it_interval.tv_sec = 0;
    tick.it_interval.tv_usec = 1000;   //每10毫秒切一次執行緒 
    setitimer(ITIMER_REAL,&tick,NULL);
}


void Mythread::destroyThread(int id)
{
    free(threadMap_[id]->uc_stack.ss_sp);    //釋放執行緒棧空間
    threadMap_.erase(id);   //將map中的執行緒上下文刪除
}

int Mythread::makeThreadId(void)
{
    if((--threadMap_.end())->first != threadMap_.size())    //說明map中有未利用的id
    {
        int i = 1;
        for(auto it = threadMap_.begin(); it != threadMap_.end(); i++,it++)
        {
            if(i != it->first)
            {
                printf("return  = %d\n",i);
                return i;   
            }
        }
    }
    else
    {
        return threadMap_.size() + 1;
    }

    return 0;
}

void Mythread::threadSchedule(int n)
{
    if(threadMap_.size() > 1)
    {
        int lastId = current_;  //儲存當前id
        if(current_ != (--threadMap_.end())->first)//當前執行緒不是map中的最後一個
        {
            auto it = threadMap_.find(current_);
            current_ = (++it)->first;
        }
        else
        {
            current_ = threadMap_.begin()->first;   //從map的起點開始
        }

        swapcontext(threadMap_[lastId].get(),threadMap_[current_].get());   //切換執行緒
    }
}

測試程式碼如下

#include <iostream>
#include <vector>
#include <string>
#include "coroutine.h"
#include <unistd.h>

void func(void)
{
    while(true)
    {
        printf("hello\n");
    }
}

int main(int argc,char **argv)
{
  mythread::Mythread t;
  t.start();
  t.newThread(func);
  printf("hehe\n");

  while(1)
  {
    printf("world\n");
  }
  return 0;
}

如上述程式碼我們呼叫newThread介面建立一個執行緒去執行func函式，該函式迴圈列印hello，而主執行緒迴圈列印world
我們把定時器頻率調為10微妙
執行部分結果如下

可以看出hello與world在無規律的交替列印

4.重點思路解析

我的設計其實很簡單，就是用一個map來儲存執行緒id和對應的執行緒上下文，每當我們建立新的執行緒(即呼叫makecontext之後)，就將對應的執行緒id和上下文存入map。然後就是執行緒排程了，我的排程演算法也很簡單，就是給每個執行緒具體的時間片，然後輪流執行

5.總結

之所以會寫這個小玩意，是昨天突然看到了ucontext.h中的API，一時手癢就自己實現一下，其中有好多不足之處，之後也會不斷改進，並擴充，有興趣的可以一起搞
原始碼在這裡https://github.com/Miaoshuai/Coroutine