ucontext实现的用户级多线程框架
昨天看CN-Erlounge-IV讲搞的其中一篇<erlang进程模型在C++中的实践>,对用coroutine实现用户态的线程非常感兴趣,于是查下资料
写了个简单的实验框架,其中schedule算法的实现很简单,只是遍历所有可以执行的coroutine.
代码如下:
uthread.h
/*
* brief: 用ucontext实现的用户级线程框架
* author: kenny huang
* date: 2009/10/13
* email: huangweilook@21cn.com
*/
#ifndef _UTHREAD_H
#define _UTHREAD_H
#include <ucontext.h>
#include <stdio.h>
#include <string.h>
#include <list>
#define MAX_UTHREAD 128
typedef int uthread_id;
#define INVAID_ID -1
//用户态线程的当前状态
enum thread_status
{
ACTIVED = 0,//可运行的
BLOCKED,//被阻塞
SLEEP,//主动休眠
DIE,//死死亡
};
class runnable
{
public:
virtual void main_routine() = 0;
};
class Scheduler;
/*
* 用户态线程
*/
class u_thread
{
friend class Scheduler;
private:
u_thread(runnable *rable,unsigned int ssize,uthread_id uid)
:ssize(ssize),_status(BLOCKED),rable(rable),uid(uid)
{
stack = new char[ssize];
ucontext.uc_stack.ss_sp = stack;
ucontext.uc_stack.ss_size = ssize;
getcontext(&ucontext);
}
~u_thread()
{
delete []stack;
}
static void star_routine();
public:
ucontext_t &GetContext()
{
return ucontext;
}
void SetStatus(thread_status _status)
{
this->_status = _status;
}
thread_status GetStatus()
{
return _status;
}
uthread_id GetUid()
{
return uid;
}
//休眠time时间
static void sleep(uthread_id utid,int t);
private:
ucontext_t ucontext;
char *stack;//coroutine使用的栈
unsigned int ssize;//栈的大小
thread_status _status;
runnable *rable;
uthread_id uid;
};
/*
* 任务调度器
*/
class Scheduler
{
//friend void u_thread::star_routine();
friend class u_thread;
public:
static void scheduler_init();
static void schedule();
static uthread_id uthread_create(runnable *rable,unsigned int stacksize);
private:
static u_thread *GetCurrentUThread()
{
if(current == -1)
return NULL;
return threads[current];
}
//休眠time时间
static void sleep(uthread_id utid,int t);
private:
static std::list<u_thread*> activeList;//可运行uthread列表
static std::list<std::pair<u_thread*,time_t> > sleepList;//正在睡眠uthread列表
static char stack[4096];
static ucontext_t ucontext;
static u_thread *threads[MAX_UTHREAD];
static int total_count;
static int current;//在uthread创建时使用的
};
#endif
uthread.cpp
#include "uthread.h"
#include <assert.h>
#include <stdlib.h>
#include <time.h>
ucontext_t Scheduler::ucontext;
char Scheduler::stack[4096];
u_thread *Scheduler::threads[128];
int Scheduler::total_count = 0;
int Scheduler::current = -1;
std::list<u_thread*> Scheduler::activeList;
std::list<std::pair<u_thread*,time_t> > Scheduler::sleepList;
void u_thread::sleep(uthread_id utid,int t)
{
Scheduler::sleep(utid,t);
}
void u_thread::star_routine()
{
u_thread *current_uthread = Scheduler::GetCurrentUThread();
assert(current_uthread);
//回到Scheduler::uthread_create
current_uthread->SetStatus(ACTIVED);
ucontext_t &cur_context = current_uthread->GetContext();
swapcontext(&cur_context,&Scheduler::ucontext);
current_uthread->rable->main_routine();
current_uthread->SetStatus(DIE);
}
void Scheduler::scheduler_init()
{
for(int i = 0; i < MAX_UTHREAD; ++i)
threads[i] = 0;
getcontext(&ucontext);
ucontext.uc_stack.ss_sp = stack;
ucontext.uc_stack.ss_size = sizeof(stack);
ucontext.uc_link = NULL;
makecontext(&ucontext,schedule, 0);
}
void Scheduler::schedule()
{
while(total_count > 0)
{
//首先执行active列表中的uthread
std::list<u_thread*>::iterator it = activeList.begin();
std::list<u_thread*>::iterator end = activeList.end();
for( ; it != end; ++it)
{
if(*it && (*it)->GetStatus() == ACTIVED)
{
ucontext_t &cur_context = (*it)->GetContext();
swapcontext(&ucontext,&cur_context);
uthread_id uid = (*it)->GetUid();
if((*it)->GetStatus() == DIE)
{
printf("%d die/n",uid);
delete threads[uid];
threads[uid] = 0;
--total_count;
activeList.erase(it);
break;
}
else if((*it)->GetStatus() == SLEEP)
{
printf("%d sleep/n",uid);
activeList.erase(it);
break;
}
}
}
//看看Sleep列表中是否有uthread该醒来了
std::list<std::pair<u_thread*,time_t> >::iterator its = sleepList.begin();
std::list<std::pair<u_thread*,time_t> >::iterator ends = sleepList.end();
time_t now = time(NULL);
for( ; its != ends; ++its)
{
//可以醒来了
if(now >= its->second)
{
u_thread *uthread = its->first;
uthread->SetStatus(ACTIVED);
activeList.push_back(uthread);
sleepList.erase(its);
break;
}
}
}
printf("scheduler end/n");
}
uthread_id Scheduler::uthread_create(runnable *rable,unsigned int stacksize)
{
if(total_count >= MAX_UTHREAD)
return INVAID_ID;
int i = 0;
for( ; i < MAX_UTHREAD; ++i)
{
if(threads[i] == 0)
{
threads[i] = new u_thread(rable,stacksize,i);
++total_count;
current = i;
ucontext_t &cur_context = threads[i]->GetContext();
cur_context.uc_link = &ucontext;
makecontext(&cur_context,u_thread::star_routine, 0);
swapcontext(&ucontext, &cur_context);
current = -1;
activeList.push_back(threads[i]);
return i;
}
}
}
void Scheduler::sleep(uthread_id utid,int t)
{
if(utid == INVAID_ID)
return;
assert(threads[utid]);
time_t now = time(NULL);
now += t;
printf("wake up time %u/n",now);
//插入到sleep列表中
sleepList.push_back(std::make_pair(threads[utid],now));
//保存当前上下文切换回scheduler
threads[utid]->SetStatus(SLEEP);
ucontext_t &cur_context = threads[utid]->GetContext();
swapcontext(&cur_context,&Scheduler::ucontext);
}
uthreadtest.cpp
// kcoroutine.cpp : 定义控制台应用程序的入口点。
//
#include "uthread.h"
class runable_test : public runnable
{
public:
runable_test(const char *name):name(name){}
void main_routine()
{
for(int i =0 ; i < 10 ; ++i)
{
printf("%s/n",name);
u_thread::sleep(uid,1);
printf("%s wake up/n",name);
}
}
const char *name;
uthread_id uid;
};
int main()
{
//首先初始化调度器
Scheduler::scheduler_init();
runable_test t1("0");
runable_test t2("1");
runable_test t3("2");
runable_test t4("3");
//创建4个用户级线程
t1.uid = Scheduler::uthread_create(&t1,4096);
t2.uid = Scheduler::uthread_create(&t2,4096);
t3.uid = Scheduler::uthread_create(&t3,4096);
t4.uid = Scheduler::uthread_create(&t4,4096);
printf("create finish/n");
//开始调度线程的运行
Scheduler::schedule();
return 0;
}
在linux下执行
g++ -o test uthreadtest.cpp uthread.cpp
便可生成可执行文件
