模拟实现一个多线程环境

引言

初学者或者一些有经验的开发人员，并不总是对于系统底层有清楚的了解。比如，进程（或线程）调度是如何实现的？往往只停留于模糊的认识。了解这些问题的最好途径是亲自实践。然而开发一个真实系统的门槛很高，而通过学习一个已有系统来了解也非易事，因为错综复杂的代码和关系有时把人搞糊涂了。于是学习者往往写一些模拟程序来努力表达系统是怎样运作的。不过，这些程序往往过于简单。于是“看看能否写一个模拟进程调度的软件”，从这个想法出发我尝试写一个接近真实的调度程序，因为进程或线程调度是现代操作系统的核心部分。经过一段时间的摸索一个调度程序写成了，同时写了一个简单的内存管理。接下来实现了一个模拟文件系统，差不多是按着0.11版的Linux文件系统实现的。我把这个模拟系统看作是学习和实践的一个场所，因此我主要用C++语言而不是C语言来编写，因为面向对象的方法（接口和类）更容易表达要被理解的东西。毕竟这是一个模拟程序，首要目标是帮助人学习和亲自实践，而不是以追求实现效率为先。目前这个模拟系统是在Windows平台上实现的，但它也可能在其它平台上实现。因为这个系统中只有少量与平台或硬件有关的代码，在不同平台上这部分的实现将有差异。

多线程/进程的模拟实现

线程及线程切换的概念

我们先来回顾下线程及其切换的概念。计算机通常按顺序一条一条地执行程序指令。多数处理器（CPU）通常内部借助一些寄存器来完成指令的执行，例如程序计数器（PC），指向下一条要执行的指令，其它是一些数据或状态寄存器等。另外，许多计算机支持使用堆栈（stack）来传递函数参数，存放局部变量等，因为寄存器的数量毕竟有限。通常用一个堆栈寄存器（SP）来指向当前所用的堆栈。当一段程序代码被执行的时候，处理器就处在一个状态中，这个状态可以用当前的程序计数器，堆栈指针，以及其它一些寄存器的集合来定义。如果我们把这个状态保存下来，转去执行其它代码，一段时间后再回过来，把先前保存的状态恢复，使各个寄存器恢复到以前保存的那个状态，继续执行下去，那么这一段程序的执行就好像没有被打断一样。这样一段程序的执行，就像一个独立的执行流或路径，这就是一个线程（thread）的含义了。系统中可以有许多线程，只要对每个线程都按照保存、恢复，恢复、保存来处理，就看起来像是同时各自独立运行。至于线程切换，就是把当前线程的执行状态保存起来，然后把另一个线程的已保存状态恢复过来，成为当前，这就完成切换了。

线程切换的实现

虽然我们大概明白线程及其切换的原理，但编写代码实现出来是最重要的。在寻求实现的过程中，我曾担心一件事：线程切换的实现，是否离不开特殊硬件指令的支持？恐怕是特权指令。我看到一篇网友的文章，他在用户程序中给出了从一个函数切换到另一个函数的例子，他的函数相当于线程函数。因此我参照他的代码在Windows平台上实现了。我用的开发工具为vs2008，为了完成线程切换，需要嵌入Intel汇编指令。

线程切换实现代码

void threadSwitch(int *pCurrentESP, int *pCurrentEIP, int nextESP, int nextEIP){    __asm    {        push eax        push ebx        push ecx        push edx        push esi        push edi        push ebp        //save ESP        mov ebx,esp        mov eax,[pCurrentESP]        mov [eax],ebx        //restore ESP        mov eax,nextESP        mov esp,eax        //Save EIP        lea ebx, _RECOVER_        mov eax, [pCurrentEIP]        mov [eax],ebx        //Restore EIP        mov eax, nextEIP        push eax        ret_RECOVER_:        pop ebp        pop edi        pop esi        pop edx        pop ecx        pop ebx        pop eax    }}

我们来分析这段代码如何完成切换的。pCurrentESP指向一个地址，用来存放当前线程的堆栈指针。pCurrentEIP也指向一个地址，用来存放当前线程的下一条指令地址。nextESP和nextEIP分别是将要切换过去的线程（简称下一个线程）的堆栈指针和下一条指令地址。切换的目标是把当前执行环境保存起来，并把下一个线程环境恢复成为当前。首先从push eax到push ebp是把一些通用寄存器保存到当前堆栈中 - 这个堆栈通常就属于这个线程。接下来保存当前线程的ESP，即堆栈指针，保存到pCurrentESP指向的地方 - 通常位于线程的内部数据结构中。后面又把当前线程的下一条指令地址保存起来，通常也是保存到线程内部数据结构中。请注意，下一条指令指向哪里？指向的是_RECOVER_标号处。这样，当以后再切回这个线程时，将执行_RECOVER_标号处代码，这部分代码所作的正是从堆栈中弹出和恢复那些通用寄存器的内容，这样就恢复到这个线程切换前的状态了。现在来看对下一个线程执行环境的恢复。首先是恢复堆栈指针，即把nextESP的内容赋给ESP寄存器，接下来恢复指令计数器EIP。由于EIP不能直接修改，这里利用堆栈并ret指令达到间接改变EIP的目的。这样就跳到下一个线程执行去了（如果此线程也调用这里的切换代码或者类似代码，可能马上就从堆栈中恢复那些通用寄存器，如前面所分析的），下一个线程成为新的当前线程。

我很高兴在上述线程切换的实现中，并未依赖于特殊硬件指令。这部分代码在所在平台下经过测试，证明可以工作。于是，我们在用户程序空间里实现了线程切换，因为模拟程序通常作为宿主机系统上的一个用户进程来运行。当前的实现，是Windows上的一个用户进程。

一个细节：上述切换代码，我定义成一个函数供调用，而不是使用宏（如linux的switch_to宏）。这个函数形式也是可行的。几个参数pCurrentESP，pCurrentEIP，nextESP，nextEIP是该函数的局部变量。C汇编代码对局部变量的访问是通过EBP寄存器。注意切换过程中虽然堆栈指针ESP被改变，但EBP并未改变，因此对这几个局部变量的访问总是有效的。

线程/进程管理类（接口）

线程切换实现之后，其它如线程的内部数据结构，线程调度等相对来说比较容易了。我打算把线程和进程的有关功能放到一个类中。为了清晰，先定义一个线程/进程的管理接口。我也决定在这个模拟系统中，以线程为基本调度单元。一个进程可以有一个或多个线程，其中有一个线程为主线程（主线程若结束，这个进程就要销毁了）。下面是线程/进程管理类接口，其中的接口函数都定义为纯虚函数。

线程/进程管理接口

typedef int (*THREAD_PROC)(void *parameter);class ProcessManager{public://创建一个进程和其主线程。成功返回该进程的id（进程范围内唯一，大于0），失败返回0。//主线程和其它线程的区别是，主线程运行结束，进程就终止，属于该进程的所有线程都释放。virtual int createProcess(THREAD_PROC mainThreadProc, void *parameter,                 int stackSizeInKB=1024, bool readyToRun=true) = 0;//创建一个线程。成功返回该线程的id（线程范围内唯一，大于0），失败返回0。//为了简化编程，约定线程id从1开始顺序编号（0为系统空闲线程所用）。virtual int createThread(THREAD_PROC threadProc, void *parameter,                 int stackSizeInKB=1024, bool readyToRun=true) = 0;//进程/线程调度。//对于合作式的线程调度，需要每个线程主动调用调度函数，让其它线程有机会执行。virtual void schedule() = 0;//获取当前进程的id。virtual int getCurrentProcessId() = 0;//获取当前线程的id。virtual int getCurrentThreadId() = 0;//获取进程的当前工作路径virtual const char *getCurrentDir() = 0;//设置进程的当前工作目录virtual void setCurrentDir(const char *pathname) = 0;//使当前线程睡眠指定的毫秒数virtual void sleep(int msecs) = 0;//获取锁，成功将拥有这个锁（如果之前已获取这个锁，将增加引用计数）。//如果锁已经被其它线程拥有，调用线程将阻塞。//一个锁可以被同一线程多次获取，但释放也要匹配相同的次数，否则其它线程不能获取它virtual void lock(long lock) = 0;//尝试获取锁，成功将拥有这个锁。如果锁已经被其它线程拥有，立即返回falsevirtual bool trylock(long lock) = 0;//释放锁virtual void unlock(long lock) = 0;};

这个线程/进程管理接口最主要的就是支持线程的创建，进程的创建，以及调度。在这里调度的基本含义是指线程调度，因为线程已作为基本调度单位。

对这个接口类需要作些说明。THREAD_PROC是线程函数的原型定义。schedule()是调度函数。为何要把调度函数公开出来呢？因为这个模拟系统目前只支持共享方式的调度。也就是说，这个系统中的每个线程需要主动放弃控制权，好让其它线程有机会运行。假如有个线程不释放控制权，从来不调用schedule()，它就一直独占系统，以致其它线程没有机会执行。此种情况类似一些早期的系统，例如早期Windows系统。如果要实现抢先式调度，就要接管中断和中断处理，因为中断能打断当前程序（线程）的执行，在中断处理函数中可以实现调度。模拟程序目前没有寻到一个方法来支持抢先式调度。createProcess是支持创建进程的接口函数，目前它是简单原始的。我们还未实现从磁盘可执行文件加载和创建进程。至于sleep和线程锁，放在这里主要是展示对于线程调度技术的运用。

线程/进程管理类的实现

我通常会先选择一种简单的实现。如果时间允许，或者有了想法，再去改进或写各种变化的实现。这样的做法是常见的。这个模拟系统，适合作为一个学习和练习的场所。

所用到的一些结构

//存放进程相关信息的结构class ProcessInternalInfo{public:    int processId;    char currentDir[300];    ProcessInternalInfo();};//存放线程相关信息的结构class ThreadInternalInfo{public:    //线程id及线程所属的进程id    int processId;    int threadId;    //线程切换时对现场的保存和恢复，主要是栈顶指针(esp)和指令计数器(eip)    int esp;    int eip;    //线程所使用的用户栈及其大小    char *stackBase;    int stackSize;    //字节    //线程函数及其参数    THREAD_PROC threadProc;    void *parameter;    //是否进程的主线程    bool isMainThread;    //错误代码    int error;    ThreadInternalInfo();};//内部堆栈，内部堆栈应该很小，因为只有thread wrapper function才用到struct InternalStack{    char stack[4*1024];};//锁的实现结构class Thread_Lock{public:    long lock;    int threadIndex;    int refCount;    Thread_Lock()    {        lock = 0;        threadIndex = -1;        refCount = 0;    }};class Thread_Wait{public:    int threadIndex;    long lock;    Thread_Wait()    {        threadIndex = -1;        lock = 0;    }};

管理实现类的定义

class ProcessManagerImpl : public ProcessManager{public:ProcessManagerImpl();virtual ~ProcessManagerImpl();//初始化bool initManageData();virtual int createProcess(THREAD_PROC mainThreadProc, void *parameter,             int stackSizeInKB=1024, bool readyToRun=true);virtual int createThread(THREAD_PROC threadProc, void *parameter,             int stackSizeInKB=1024, bool readyToRun=true);virtual void schedule();virtual int getCurrentProcessId();virtual int getCurrentThreadId();virtual const char *getCurrentDir();virtual void setCurrentDir(const char *pathname);virtual void sleep(int msecs);virtual void lock(long lock);virtual bool trylock(long lock);virtual void unlock(long lock);//运行第一个进程，进程id为0。使用程序当前的堆栈。int runProcess0(THREAD_PROC threadProc, void *parameter);void setError(int error);int getError();protected://这里采用数组和索引管理所有进程/线程ProcessInternalInfo *_pProcessInfo;ThreadInternalInfo *_pThreadInfo;//指向就绪线程队列int *_pThreadReady;//指向阻塞线程队列int *_pThreadBlock;//为每个线程分配一个内部栈。因为用户线程函数结束后，用户栈将被删除，//thread wrapper function不能依靠用户栈工作InternalStack *_pInternalStack;protected://释放相关资源void freeManageData();//查找未用的进程槽，返回索引。未找到返回-1。int find_free_process();//查找未用的线程槽，返回索引。未找到返回-1。int find_free_thread();//加入到就绪线程队列void addThreadReady(int threadIndex);//加入到阻塞线程队列void addThreadBlock(int threadIndex);//创建线程int create_thread(int processId, bool isMainThread, THREAD_PROC threadProc,                  void *parameter, int stackSizeInKB, bool readyToRun);//thread wrapper function//用户线程结束时要释放堆栈，并从调度队列中删除，所以需要一个对用户线程函数的包装static void thread_wrapper_func(ProcessManagerImpl *pImpl, int threadIndex);//从就绪线程队列中删除void removeReadyThread(int threadIndex);//从阻塞线程队列中删除void removeBlockThread(int threadIndex);//删除一个线程（重置对应的线程槽）void removeThread(int threadIndex);//删除一个进程（重置对应的进程槽）void removeProcess(int processIndex);//线程切换void threadSwitch(int *pCurrentESP, int *pCurrentEIP, int nextESP, int nextEIP);//系统死机 - 通常由于内部错误导致无法处理的情况，就进入这里void system_dead();//使当前线程睡眠，放入阻塞队列，然后切换到下一个线程void block();//唤醒一个线程，即从阻塞队列移除，放到就绪队列void wakeUp(int threadIndex);protected://对sleep的支持//所有由于调用sleep函数导致睡眠的，超时时间记录在这里，单位毫秒。int *_pThreadSleepTimeout;//检查看是否有线程的睡眠时间到了，把所有这样的线程唤醒void checkSleepTimeout();//对锁的支持Thread_Lock *_pThreadLock;    //存放锁的数组int _threadLockCount;Thread_Wait *_pThreadWait;    //等待锁的线程int _threadWaitCount;//查找锁，若找到返回在数组中的索引，未找到返回-1。int findLock(long lock);void removeLockByIndex(int lockIndex);void addWait(int threadIndex, long lock);//查找等待给定锁的线程，若找到，从等待中删除并返回线程号；若未找到返回-1。int removeWait(long lock);//对阻塞式文件读写的支持//线程由于等待事件而睡眠的，等待的事件存放在下面的数组中HANDLE *_pThreadEvent;//线程等待事件，可能进入睡眠，直到事件变为信号状态而被唤醒void waitEvent(HANDLE hEvent);//检查所有的等待事件，把这样的线程唤醒void checkThreadEvent();void removeThreadEvent(int threadIndex);friend class BlockedFileDisk;};

在这个实现中，我使用了一个数组来存放所有的进程对象（_pProcessInfo所指）。一个数组来存放所有的线程对象（pThreadInfo所指）。线程会阻塞或者就绪，_pThreadReady指向就绪队列，pThreadBlock指向阻塞队列。这两个队列的元素存的是线程对象索引。使用这个线程/进程管理类之前，先要把这些数据初始化，这通过调用initManageData()来达到。

构造和初始化

#define MAX_PROCESS_NUM    1024#define MAX_THREAD_NUM    2048#define MAX_LOCK_NUM    200ProcessInternalInfo::ProcessInternalInfo(){    processId = -1;    //有效的进程id从0开始    memset(currentDir, 0 ,sizeof(currentDir));    strcpy(currentDir, "/");}ThreadInternalInfo::ThreadInternalInfo(){    processId = -1;    threadId = -1;    //有效的线程id从0开始    esp = 0;    eip = 0;    stackBase = NULL;    stackSize = 0;    threadProc = NULL;    parameter = NULL;　　isMainThread = false;    error = 0;}ProcessManagerImpl::ProcessManagerImpl(){    //改为明确调用    //initManageData();}ProcessManagerImpl::~ProcessManagerImpl(){    freeManageData();}bool ProcessManagerImpl::initManageData(){    _pProcessInfo = new ProcessInternalInfo [MAX_PROCESS_NUM];    if (!_pProcessInfo) return false;    _pThreadInfo = new ThreadInternalInfo [MAX_THREAD_NUM];    if (!_pThreadInfo) return false;    _pThreadReady = new int [MAX_THREAD_NUM];    if (!_pThreadReady) return false;    for (int i = 0; i < MAX_THREAD_NUM; i++) _pThreadReady[i] = -1;    _pThreadBlock = new int [MAX_THREAD_NUM];    if (!_pThreadBlock) return false;    for (int i = 0; i < MAX_THREAD_NUM; i++) _pThreadBlock[i] = -1;    _pInternalStack = new InternalStack [MAX_THREAD_NUM];    if (!_pInternalStack) return false;    _pThreadSleepTimeout = new int [MAX_THREAD_NUM];    if (!_pThreadSleepTimeout) return false;    for (int i = 0; i < MAX_THREAD_NUM; i++) _pThreadSleepTimeout[i] = -1;    _pThreadLock = new Thread_Lock [MAX_LOCK_NUM];    if (!_pThreadLock) return false;    _threadLockCount = 0;    _pThreadWait = new Thread_Wait [MAX_THREAD_NUM];    if (!_pThreadWait) return false;　　_threadWaitCount = 0;    _pThreadEvent = new HANDLE [MAX_THREAD_NUM];    if (!_pThreadEvent) return false;    for (int i = 0; i < MAX_THREAD_NUM; i++) _pThreadEvent[i] = INVALID_HANDLE_VALUE;    return true;}void ProcessManagerImpl::freeManageData(){    delete [] _pThreadEvent;    delete [] _pThreadWait;    delete [] _pThreadLock;    delete [] _pThreadSleepTimeout;    delete [] _pInternalStack;    delete [] _pThreadBlock;    delete [] _pThreadReady;    delete [] _pThreadInfo;    delete [] _pProcessInfo;}

l 创建进程（createProcess）

进程创建实现

int ProcessManagerImpl::createProcess(THREAD_PROC mainThreadProc, void *parameter,                         int stackSizeInKB, bool readyToRun){    int freeProcessIndex = find_free_process();    if (freeProcessIndex == -1)        return 0;    ProcessInternalInfo processInfo;    processInfo.processId = freeProcessIndex;    int threadIndex = create_thread(freeProcessIndex, true, mainThreadProc,                         parameter, stackSizeInKB, readyToRun);    if (threadIndex == 0)        return 0;    _pProcessInfo[freeProcessIndex] = processInfo;    return freeProcessIndex;}

目前对进程的支持比较简单。这不是一个完整的进程创建过程，因为它假定进程的程序代码已经在内存中了。首先find_free_process查找进程数组，找到一个空闲槽，接着创建这个进程的主线程，成功地话就占用那个进程槽。这样一个进程就算建立了。如果此进程打算使用多个线程，它可以调用createThread创建其它线程。

l 创建线程（createThread）

线程创建实现

int ProcessManagerImpl::createThread(THREAD_PROC threadProc, void *parameter,                     int stackSizeInKB, bool readyToRun){    int processId = getCurrentProcessId();    return create_thread(processId, false, threadProc, 　　　　parameter, stackSizeInKB, readyToRun);}int ProcessManagerImpl::create_thread(int processId, bool isMainThread, 　　　　THREAD_PROC threadProc, void *parameter, int stackSizeInKB, bool readyToRun){    if (stackSizeInKB < 0)        return 0;    if (stackSizeInKB == 0)        stackSizeInKB = 1024;    int freeThreadIndex = find_free_thread();    if (freeThreadIndex == -1)        return 0;    //申请用户栈空间    int stackSizeInByte = stackSizeInKB * 1024;    char *pStack = new char [stackSizeInByte];    //char *pStack = (char *)GetMemoryManager()->alloc(stackSizeInByte);    if (pStack == NULL)        return 0;    ThreadInternalInfo threadInfo;    threadInfo.processId = processId;    threadInfo.threadId = freeThreadIndex;    threadInfo.stackBase = pStack;    threadInfo.stackSize = stackSizeInByte;    threadInfo.threadProc = threadProc;    threadInfo.parameter = parameter;    threadInfo.isMainThread = isMainThread;    //准备线程初始的esp和eip，eip指向线程wrapper函数的入口地址, esp指向内部栈    //由于线程wrapper函数需要两个参数，按照C调用约定，从右到左把这两个参数压入栈，    //另外函数返回地址也要占去4个字节，故esp为栈顶减去12个字节。    void (*thread_wrapper_func_ptr)(ProcessManagerImpl *, int);    thread_wrapper_func_ptr = &thread_wrapper_func;    threadInfo.eip = (int)thread_wrapper_func_ptr;    threadInfo.esp = (int)(_pInternalStack[freeThreadIndex].stack                 + sizeof(_pInternalStack[freeThreadIndex].stack) - 12);    ProcessManagerImpl **ppImpl = (ProcessManagerImpl **)(threadInfo.esp + 4);    *ppImpl = this;    int *pInt = (int *)(threadInfo.esp + 8);    *pInt = freeThreadIndex;    _pThreadInfo[freeThreadIndex] = threadInfo;    //新线程加入就绪队列    if (readyToRun)        addThreadReady(freeThreadIndex);    else        addThreadBlock(freeThreadIndex);    return freeThreadIndex;}

创建线程的主要工作在create_thread()中完成。基本过程是：找到一个空闲线程槽，创建用户堆栈，初始化线程数据结构。线程数据结构中特别需要说明的是eip和esp的初始赋值：eip指向线程的入口代码，esp指向线程的堆栈。当调度运行这个线程时，就将跳到eip所指向的地址，同时将堆栈寄存器设置为esp的值。那么eip和esp的初始值分别是什么呢？一个自然的想法是：eip指向用户线程函数threadProc，esp指向用户堆栈。但这样的话，线程运行结束后，线程所用的资源（例如用户堆栈）在哪里释放呢？它既然运行结束，就应该把控制权转移给其它线程，在哪里把控制权转移呢？思考这些问题的结果是：需要一个线程包装函数，在用户线程函数的前后做这些工作。当线程运行结束后，用户堆栈将被释放，因此我使用线程的一个内部堆栈，在内部堆栈上做这些收尾工作。内部堆栈通常1K到4K就够了。如此看来，eip应该指向用户线程函数的包装函数，esp指向线程内部栈。

线程包装函数

//thread wrapper function//用户线程结束时要释放堆栈，并从调度队列中删除，所以需要一个对用户线程函数的包装//注意：由于内部堆栈很小，要小心，建议不要调用什么C库函数，例如printfvoid ProcessManagerImpl::thread_wrapper_func(ProcessManagerImpl *pImpl,                                              int threadIndex){    ThreadInternalInfo threadInfo = pImpl->_pThreadInfo[threadIndex];    THREAD_PROC threadProc = threadInfo.threadProc;    void *parameter = threadInfo.parameter;    int userESP = (int)(threadInfo.stackBase + threadInfo.stackSize);    int oldESP;    //接下来切换到用户堆栈    __asm    {        mov eax,esp        mov oldESP,eax        mov eax,userESP        mov esp,eax    }    //执行用户线程函数    threadProc(parameter);    //函数调用完成之后，通常ebp是不会改变，对局部变量的访问仍然有效    //恢复到内部堆栈    _asm    {        mov eax,oldESP        mov esp,eax    }    //线程函数执行完毕，从就绪队列中移去，从线程队列中也移去    pImpl->removeReadyThread(threadIndex);    pImpl->removeThread(threadIndex);    //如果是主线程，则释放该进程的一切资源，包括属于该进程的所有线程    if (threadInfo.isMainThread)    {        int processId = threadInfo.processId;        for (int i = 0; i < MAX_THREAD_NUM; i++)        {            if (pImpl->_pThreadInfo[i].processId == processId)            {                //将该线程从阻塞或是就绪就列中删除                pImpl->removeReadyThread(i);                pImpl->removeBlockThread(i);                pImpl->removeThreadEvent(i);                pImpl->removeThread(i);            }        }        pImpl->removeProcess(processId);    }    //找到下一个就绪线程，成为当前并切过去    //如果有线程由于调用sleep进入休眠的，检查和唤醒之　　pImpl->checkSleepTimeout();        pImpl->checkThreadEvent();    int currentThreadIndex = pImpl->_pThreadReady[0];    if (currentThreadIndex != -1)    {        int currentESP = pImpl->_pThreadInfo[currentThreadIndex].esp;        int currentEIP = pImpl->_pThreadInfo[currentThreadIndex].eip;        //切过去        __asm        {            //restore ESP            mov eax,currentESP            mov esp,eax            //Restore EIP            mov eax,currentEIP            push eax            ret        }    } else    {    //就绪队列为空，这应该不会发生，因为Process0总会存在        pImpl->system_dead();    }}

在这个线程包装函数中，需要注意的一点，就是执行用户线程函数threadProc前后堆栈的改变。执行threadProc前堆栈改为用户堆栈，执行threadProc后堆栈恢复为内部堆栈。接下来对这个线程资源的释放都在内部堆栈上进行。

l 调度函数（schedule）

调度函数实现

void ProcessManagerImpl::schedule(){    //由于线程需要主动让出CPU，让其它线程有机会执行，故在调度上按均等机会处理    //做法是：查找下一个就绪线程，把它提为当前线程，原来的线程移到就绪队列末尾    //如果没有下一个就绪线程，则立即返回，继续执行当前线程    //如果有线程由于调用sleep进入休眠的，检查和唤醒之    checkSleepTimeout();    checkThreadEvent();    int currentThreadIndex = _pThreadReady[0];    int nextThreadIndex = _pThreadReady[1];    if (nextThreadIndex == -1)        return;    //下一个就绪线程提为当前    int i;    for (i = 1; i < MAX_THREAD_NUM; i++)    {        if (_pThreadReady[i] != -1)             _pThreadReady[i-1] = _pThreadReady[i];        else            break;    }    _pThreadReady[i-1] = currentThreadIndex;        //准备切换，切换时主要保存EBP（栈帧指针）、ESP（当前栈指针）和EIP（指令计数器），    //并要修改ESP和EIP，对ESP的修改，不影响对于局部变量的访问（因为是通过EBP进行的）    int *pCurrentESP = &(_pThreadInfo[currentThreadIndex].esp);    int *pCurrentEIP = &(_pThreadInfo[currentThreadIndex].eip);    int nextESP = _pThreadInfo[nextThreadIndex].esp;    int nextEIP = _pThreadInfo[nextThreadIndex].eip;    threadSwitch(pCurrentESP,pCurrentEIP,nextESP,nextEIP);}

就绪线程队列的首个元素（下标为0），就指向当前线程。由于这个模拟系统是共享式调度，所以简单地采用顺序调度的方式切到下一个线程，原先的线程就移到就绪队列的末尾。完成切换的代码就是前面我们介绍过的threadSwitch函数。也可以实现其它调度算法，例如如果线程有优先级，可以实现基于优先级的调度算法。

l 其它函数

下面列出了线程/进程管理类的一些其它函数，其中多数是辅助实现函数。

一些其它函数

//获取当前进程的id。int ProcessManagerImpl::getCurrentProcessId(){    int currentThreadIndex = _pThreadReady[0];    return _pThreadInfo[currentThreadIndex].processId;}//获取当前线程的id。int ProcessManagerImpl::getCurrentThreadId(){    int currentThreadIndex = _pThreadReady[0];    return currentThreadIndex;}//获取进程的当前工作路径const char *ProcessManagerImpl::getCurrentDir(){    int processIndex = getCurrentProcessId();    return _pProcessInfo[processIndex].currentDir;}//设置进程的当前工作目录void ProcessManagerImpl::setCurrentDir(const char *pathname){    int processIndex = getCurrentProcessId();    ProcessInternalInfo *process = _pProcessInfo + processIndex;    strncpy(process->currentDir, pathname, sizeof(process->currentDir)-1);}//查找未用的进程槽，返回索引。未找到返回-1。int ProcessManagerImpl::find_free_process(){    for (int i = 0; i < MAX_PROCESS_NUM; i++)    {        ProcessInternalInfo processInfo = _pProcessInfo[i];        if (processInfo.processId == -1)             return i;    }    return -1;}//查找未用的线程槽，返回索引。未找到返回-1。int ProcessManagerImpl::find_free_thread(){    for (int i = 0; i < MAX_THREAD_NUM; i++)    {        ThreadInternalInfo threadInfo = _pThreadInfo[i];        if (threadInfo.threadId == -1)             return i;    }    return -1;}//加入到就绪线程队列void ProcessManagerImpl::addThreadReady(int threadIndex){    for (int i = 0; i < MAX_THREAD_NUM; i++)    {        if (_pThreadReady[i] == -1)         {            _pThreadReady[i] = threadIndex;            return;        }    }}//加入到阻塞线程队列void ProcessManagerImpl::addThreadBlock(int threadIndex){    for (int i = 0; i < MAX_THREAD_NUM; i++)    {        if (_pThreadBlock[i] == -1)         {            _pThreadBlock[i] = threadIndex;            return;        }    }}//从就绪线程队列中删除void ProcessManagerImpl::removeReadyThread(int threadIndex){    for (int i = 0; i < MAX_THREAD_NUM; i++)    {        if (_pThreadReady[i] == threadIndex)        {            int k;            for (k = i; k < MAX_THREAD_NUM-1; k++)            {                _pThreadReady[k] = _pThreadReady[k+1];            }            _pThreadReady[k]=-1;            break;        }    }}//从阻塞线程队列中删除void ProcessManagerImpl::removeBlockThread(int threadIndex){    for (int i = 0; i < MAX_THREAD_NUM; i++)    {        if (_pThreadBlock[i] == threadIndex)        {            int k;            for (k = i; k < MAX_THREAD_NUM-1; k++)            {                _pThreadBlock[k] = _pThreadBlock[k+1];            }            _pThreadBlock[k]=-1;            break;        }    }}//删除一个线程（重置对应的线程槽）void ProcessManagerImpl::removeThread(int threadIndex){    //释放线程的堆栈    char *pStack = _pThreadInfo[threadIndex].stackBase;    delete [] pStack;    //GetMemoryManager()->free(pStack);    //线程槽数据复位，相当于删除了这个线程    ThreadInternalInfo threadInfo;    _pThreadInfo[threadIndex] = threadInfo;}//删除一个进程（重置对应的进程槽）void ProcessManagerImpl::removeProcess(int processIndex){    ProcessInternalInfo processInfo;    _pProcessInfo[processIndex] = processInfo;}//系统死机 - 通常由于内部错误导致无法处理的情况，就进入这里void ProcessManagerImpl::system_dead(){    //这里的打印有待改进，因为可能在内部栈上调用，内部栈不够printf使用...    printf("\nSorry, system is dead");    for (;;) ;}//线程等待事件，可能进入睡眠，直到事件变为信号状态而被唤醒void ProcessManagerImpl::waitEvent(HANDLE hEvent){    int teststate = WaitForSingleObject(hEvent, 0);    if (teststate == WAIT_FAILED)//出错，可能句柄无效        return;    if (teststate == WAIT_OBJECT_0)//已经是有信号状态        return;    int currentThreadIndex = _pThreadReady[0];    _pThreadEvent[currentThreadIndex] = hEvent;    block();}//检查所有的等待事件，把这样的线程唤醒void ProcessManagerImpl::checkThreadEvent(){    for (int i = 0; i < MAX_THREAD_NUM; i++)    {        HANDLE hEvent = _pThreadEvent[i];        if (hEvent != INVALID_HANDLE_VALUE)        {            int teststate = WaitForSingleObject(hEvent,0);            if (teststate == WAIT_OBJECT_0)            {                wakeUp(i);                _pThreadEvent[i] = INVALID_HANDLE_VALUE;//清除事件            }        }    }}void ProcessManagerImpl::removeThreadEvent(int threadIndex){    _pThreadEvent[threadIndex] = INVALID_HANDLE_VALUE;}//使当前线程睡眠，放入阻塞队列，然后切换到下一个线程void ProcessManagerImpl::block(){    int currentThreadIndex = _pThreadReady[0];    int nextThreadIndex = _pThreadReady[1];    if (nextThreadIndex != -1)    {        removeReadyThread(currentThreadIndex);        addThreadBlock(currentThreadIndex);        //切换到下一个线程（成为当前）        int *pCurrentESP = &(_pThreadInfo[currentThreadIndex].esp);        int *pCurrentEIP = &(_pThreadInfo[currentThreadIndex].eip);        int nextESP = _pThreadInfo[nextThreadIndex].esp;        int nextEIP = _pThreadInfo[nextThreadIndex].eip;        threadSwitch(pCurrentESP,pCurrentEIP,nextESP,nextEIP);    }    else    {        //没有下一个可调度的线程，这种情况应该不会发生，        //因为process0总是存在，而且process0也不能调用导致阻塞的函数        system_dead();    }}//唤醒一个线程，即从阻塞队列移除，放到就绪队列void ProcessManagerImpl::wakeUp(int threadIndex){    removeBlockThread(threadIndex);    addThreadReady(threadIndex);}//如果模拟系统还没有起来，就设置/获取错误代码，错误代码放在这里static int _error;//设置错误代码（最近一次系统调用）//一些系统调用（如文件系统调用）出错时需要设置错误代码，使用户得知具体错误原因。void ProcessManagerImpl::setError(int error){    int currentThreadIndex = _pThreadReady[0];    if (currentThreadIndex != -1)        _pThreadInfo[currentThreadIndex].error = error;    else        _error = error;}//取得错误代码int ProcessManagerImpl::getError(){    int currentThreadIndex = _pThreadReady[0];    int error;    if (currentThreadIndex != -1)        error = _pThreadInfo[currentThreadIndex].error;    else        error = _error;    return error;}

l sleep的实现

sleep是一个常见的系统调用。在多任务系统中，其基本的含义就是挂起当前的进程/线程，把控制权交还系统。过了指定的一段时间后，由系统唤醒这个进程/线程。现在我们在模拟系统中实现sleep调用。由于模拟系统的共享式调度特点，决定了sleep的实现虽然尽力，却不能保证睡眠时间的精确性。在共享方式调度下，有几个机会控制权会交还给系统。一个是线程主动调用schedule()的时候，一个是线程运行结束的时候。模拟系统只有在这不多的机会里检查系统时间，以确定是否唤醒那些调用sleep进入阻塞的线程。检查时间的函数是checkSleepTimeout()，这个函数在shcedule()和thread_wrapper_func()里都被调用了。sleep的实现：计算和设置超时时间，然后调用block()挂起当前线程，即把此线程从就绪队列移到阻塞队列，然后切换到下一个就绪线程。checkSleepTimeout()的实现：检查线程的sleep超时时间值，若已到达，调用wakeUp()将此线程唤醒，即从阻塞队列移到就绪队列。

sleep的实现

//使当前线程睡眠指定的毫秒数void ProcessManagerImpl::sleep(int msecs){    if (msecs <= 0)        return;    int sleepExpiredTickCount = GetTickCount() + msecs;    if (sleepExpiredTickCount <= 0)        return;    //把当前线程移到阻塞队列中，同时设置超时时间    int currentThreadIndex = _pThreadReady[0];    _pThreadSleepTimeout[currentThreadIndex] = sleepExpiredTickCount;    block();}//检查看是否有线程的睡眠时间到了，把所有这样的线程唤醒void ProcessManagerImpl::checkSleepTimeout(){    DWORD dwCurrentTickCount = GetTickCount();    for (int i = 0; i < MAX_THREAD_NUM; i++)    {        int sleepExpiredTickCount = _pThreadSleepTimeout[i];        if (sleepExpiredTickCount != -1            && dwCurrentTickCount >= sleepExpiredTickCount)        {            //唤醒这个线程，具体就是将此线程从阻塞队列移到就绪队列            wakeUp(i);            _pThreadSleepTimeout[i] = -1;    //超时值复位        }    }}

l 锁的实现

在多任务系统中，互斥锁也是常见的。作为示例，这里实现了一种可重入的互斥锁。可重入是指如果获得一个锁的线程再次获取这个锁，也将成功，只是增加引用计数。在这个实现中，简单地用一个整数来代表一个锁，并简单地用两个数组来分别管理所有的锁和等待队列，请参考线程/进程实现类中的定义。lock()的实现：若这个锁被其它线程占用，就阻塞，否则获得它或者增加引用计数（如果之前已获得）。trylock()与lock相似，只是若发现锁被其它线程占用，就立即返回，否则占用这个锁。trylock()是一个不会阻塞的调用。unlock()的实现：锁的引用计数减一，如果已到0，就唤醒一个等待的线程（如果有），此线程将是该锁的新的拥有者。

锁的实现

void ProcessManagerImpl::lock(long lock){    int currentThreadIndex = _pThreadReady[0];    int lockIndex = findLock(lock);    if (lockIndex != -1)    {        Thread_Lock theLock = _pThreadLock[lockIndex];        if (currentThreadIndex != theLock.threadIndex)        {            //其它线程拥有这个锁，当前线程只能阻塞            addWait(currentThreadIndex, lock);            block();            //从阻塞中恢复，已经拥有这个锁了        }        else        {            //之前已获取过这个锁，引用数加1            theLock.refCount++;            _pThreadLock[lockIndex] = theLock;        }    }    else    {        //获得这个锁，继续运行        if (_threadLockCount < MAX_LOCK_NUM)        {            Thread_Lock theLock;            theLock.lock = lock;            theLock.threadIndex = currentThreadIndex;            theLock.refCount = 1;            _pThreadLock[_threadLockCount] = theLock;            _threadLockCount++;        }    }}//查找锁，若找到返回在数组中的索引，未找到返回-1。int ProcessManagerImpl::findLock(long lock){    for (int i = 0; i < _threadLockCount; i++)    {        Thread_Lock theLock = _pThreadLock[i];        if (theLock.lock == lock)            return i;    }    return -1;}void ProcessManagerImpl::removeLockByIndex(int lockIndex){    for (int i = lockIndex; i < _threadLockCount-1; i++)    {        _pThreadLock[i] = _pThreadLock[i+1];    }    _threadLockCount--;}void ProcessManagerImpl::addWait(int threadIndex, long lock){    Thread_Wait wait;    wait.threadIndex = threadIndex;    wait.lock = lock;    _pThreadWait[_threadWaitCount] = wait;    _threadWaitCount++;}bool ProcessManagerImpl::trylock(long lock){    int currentThreadIndex = _pThreadReady[0];    int lockIndex = findLock(lock);    if (lockIndex != -1)    {        Thread_Lock theLock = _pThreadLock[lockIndex];        if (currentThreadIndex != theLock.threadIndex)        {            //其它线程拥有这个锁            return false;        }        else        {            //之前已获取过这个锁，引用数加1            theLock.refCount++;            _pThreadLock[lockIndex] = theLock;            return true;        }    }    else    {        //获得这个锁，继续运行        if (_threadLockCount < MAX_LOCK_NUM)        {            Thread_Lock theLock;            theLock.lock = lock;            theLock.threadIndex = currentThreadIndex;            theLock.refCount = 1;            _pThreadLock[_threadLockCount] = theLock;            _threadLockCount++;            return true;        }    }    return false;}void ProcessManagerImpl::unlock(long lock){    int currentThreadIndex = _pThreadReady[0];    int lockIndex = findLock(lock);    if (lockIndex != -1)    {        Thread_Lock theLock = _pThreadLock[lockIndex];        if (currentThreadIndex == theLock.threadIndex)        {            theLock.refCount--;            if (theLock.refCount <= 0)            {                int waitThreadIndex = removeWait(lock);                if (waitThreadIndex != -1)                {                    //唤醒这个等待的线程                    theLock.threadIndex = waitThreadIndex;                    theLock.refCount = 1;                    _pThreadLock[lockIndex] = theLock;                    wakeUp(waitThreadIndex);                }                else                {                    //没有其它线程等待这个锁，删除它                    removeLockByIndex(lockIndex);                }            }            else            {                _pThreadLock[lockIndex] = theLock;            }        }        else        {            //当前线程不拥有这个锁            return;        }    }    else    {        //锁不存在        return;    }}//查找等待给定锁的线程，若找到，从等待中删除并返回线程号；若未找到返回-1。int ProcessManagerImpl::removeWait(long lock){    int i;    for (i = 0; i < _threadWaitCount; i++)    {        if (_pThreadWait[i].lock == lock)        {            int threadIndex = _pThreadWait[i].threadIndex;            //删除这个元素（后续前移）            for (int k = i; k < _threadWaitCount-1; k++)            {                _pThreadWait[k] = _pThreadWait[k+1];            }            _threadWaitCount--;            return threadIndex;        }    }    return -1;}

多线程/进程测试运行

l 进入模拟多线程环境

我们的模拟程序通常作为宿主机上的一个进程来运行。当模拟系统启动时，从main函数开始运行。 main函数使用宿主系统提供的堆栈。我们就在main函数中创建模拟系统的第一个进程，这个进程的id为0。为此，线程/进程管理实现类提供了一个runProcess0函数，这个函数创建模拟系统中的第一个可调度进程，并立刻运行它。

runProcess0函数

//运行第一个进程，进程id为0。使用程序当前的堆栈。int ProcessManagerImpl::runProcess0(THREAD_PROC threadProc, void *parameter){    //第一个进程/线程，进程/线程号应该为0    int freeProcessIndex = find_free_process();    if (freeProcessIndex != 0)        return -1;    int freeThreadIndex = find_free_thread();    if (freeThreadIndex != 0)        return -1;    ProcessInternalInfo processInfo;    processInfo.processId = freeProcessIndex;    ThreadInternalInfo threadInfo;    threadInfo.processId = freeProcessIndex;    threadInfo.threadId = freeThreadIndex;    //我们把stackBase设为NULL，表示使用程序当前的栈    threadInfo.stackBase = NULL;    threadInfo.stackSize = 0;    threadInfo.threadProc = threadProc;    threadInfo.parameter = parameter;    //不必准备线程初始的esp和eip，因为下面即刻转去执行    _pProcessInfo[freeProcessIndex] = processInfo;    _pThreadInfo[freeThreadIndex] = threadInfo;    //新线程加入就绪队列    addThreadReady(freeThreadIndex);    int ret = threadProc(parameter);    return ret;}

这个函数与createProcess相似，所不同的是它不必为第一个进程/线程创建堆栈，而是直接用模拟程序的堆栈。另外不必初始化线程数据结构中的esp和eip，因为第一个线程是马上运行的。runProcess0()的效果是将模拟系统的（宿主机）主线程平滑地变成模拟系统中的一个进程/线程，而且是第一个。现在我们可以写出main函数的一个简单框架。

main函数的框架

ProcessManagerImpl *_process_manager;//进程0的主线程函数int thread0_proc(void *parameter){    return 0;}int main(int argc, char *argv[]){    if (!init())        return -1;    //运行进程0    int ret = _process_manager->runProcess0(thread0_proc, NULL);    unInit();    return ret;}

main函数的框架一目了然，在init中做一些初始化工作之后，就运行第一个进程。第一个进程负责产生其它的进程。第一个进程退出时，模拟系统就退出了，unInit完成清理工作。这里第一个线程函数thread0_proc还没有做任何事，似乎没有用处，但在示例代码中将给出一些测试例子。

l 使用自己的内存管理

内存管理通常都是系统的一个基本任务。这个模拟系统也实现了简单内存管理，参见后面的内存管理部分。模拟系统可以使用宿主系统提供的内存管理，也可以使用自己的内存管理。为了使用自己的内存管理，我们重载C++的new和delete运算符，使得对内存的分配和释放操作都是在一块我们管理的内存上进行。

重载new和delete

extern MemoryManager *_memory_manager;void *operator new(size_t size){    return _memory_manager->alloc(size);}void operator delete(void *p){    _memory_manager->free(p);}

l 示例代码

示例代码1

static MemoryManagerImpl _memory_manager_impl;MemoryManager *_memory_manager;ProcessManagerImpl *_process_manager;bool init(){    int managed_memory_size = 30 * 1024 * 1024;    _memory_manager_impl.setManagedMemory(managed_memory_size);    _memory_manager = &_memory_manager_impl;    _process_manager = new ProcessManagerImpl;    return _process_manager->initManageData();}void unInit(){    delete _process_manager;}//进程1的主线程函数int process1_thread1(void *parameter){    while (1)    {        int processId = _process_manager->getCurrentProcessId();        int threadId =_process_manager->getCurrentThreadId();        printf("in process %d, thread %d\n", processId, threadId);        //Sleep(500);        _process_manager->schedule();    }    return 0;}//进程0的主线程函数int thread0_proc(void *parameter){    printf("\npress any key to start\n");    getch();    int processId = _process_manager->createProcess(process1_thread1, NULL);    while (1)    {        printf("in process0\n");        _process_manager->schedule();    }    return 0;}

这个例子中使用了自己的内存管理，由于new和delete被重载了，内存管理对象自身（_memory_manager_impl）不能通过new创建，所以使用了一个静态对象。在init函数中初始化了内存管理类，此后所有涉及的内存申请和释放操作，都将在这块被管理的内存上进行。然后初始化了线程/进程管理类。

这个例子演示了线程之间的切换。我们来看进程0的主线程函数。进程0只有这一个线程。它调用createProcess创建了进程1，然后进入一个循环。这里是一个无限循环，但你可以改为一个有条件的循环，比如循环一定次数，以测试模拟系统是否正常退出。在这个循环里，它调用了schedule，以便把控制权交给其它线程。再来看进程1的主线程函数，它里面也是一个循环，同样你可以修改循环条件，以观察或调试线程的退出。它也是调用schedule交出控制权。运行这里的示例，结果如下：

in process0

in process 1, thread 1

in process0

in process 1, thread 1

in process0

in process 1, thread 1

....

如此我们看到线程之间不停地切换。因为屏幕刷新太快，可以加个延时操作，请把thread1中被注释的本地延时函数Sleep恢复（Sleep是Win32的一个调用），就可以看到延迟的效果。我们可以稍微修改上面的代码，让一个进程有多个线程，并测试sleep和锁。

示例代码2

int process1_thread2(void *parameter){    while (1)    {        printf("in process1_thread2\n");        _process_manager->sleep(30);    }    return 0;}int process1_thread1(void *parameter){    int threadId = _process_manager->createThread(process1_thread2, NULL);    while (1)    {        int processId = _process_manager->getCurrentProcessId();        int threadId =_process_manager->getCurrentThreadId();        printf("in process %d, thread %d\n", processId, threadId);        _process_manager->sleep(50);    }    return 0;}

这个例子中，进程1的主线程中，通过createThread创建了另一个线程。这样进程1就有两个线程了。这两个线程不再调用shcedule()，而是调用sleep()函数。运行这个例子，就会看到系统中有三个线程都在运行。有一点请注意，不要在thread0中调用sleep或其它导致阻塞的函数，免得模拟系统遇到没有线程可以调度的情况。至于线程锁，可以类似写些测试代码，包括测试线程之间的死锁，这里不再多说了。

内存管理

内存管理向来是操作系统的一个基本任务。我们的模拟系统当前只实现了简单的内存管理。它的目标是管理向宿主机系统申请的一块内存，把它看作是模拟系统的可分配内存空间，满足在这个内存空间上的申请和释放操作。

内存管理接口

内存管理接口定义

class MemoryManager{public://申请一块内存，size为申请的字节数virtual void *alloc(int size) = 0;//释放先前申请的内存virtual void free(void *memblock) = 0;};

 

一个简单的实现

下面是内存管理的一个简单实现。其基本思路是用一些控制块来管理内存的分配。每一块已分配的内存，都有一个控制块（Mem_Ctrl_Block），指出这块已分配内存的大小。为了简单，控制块与已分配内存块紧挨在一起，且在已分配内存块的前面。控制块中有个指针，指向下一个已分配内存的控制块。这样，所有已分配内存的控制块，由低地址往高地址形成了一个单向链表。分配内存的时候，先找链表的两头，看看有无够用空闲内存。若没有就顺着链表，依次看两个控制块之间，有无足够空闲内存用来分配。若找到就建立一个控制块，或插入到链表中，或放到链表的头或尾。释放一块已分配内存的时候，就寻找相应的控制块，找到就从链表中删除。

内存管理实现类的定义

class MemoryManagerImpl : public MemoryManager{public:MemoryManagerImpl();virtual ~MemoryManagerImpl();//设置被管理的内存大小，这块内存可以从外面传入。//如果memory为NULL，这块内存将内部申请。void setManagedMemory(int size, void *memory = NULL);int getManagedSize() const;//申请一块内存，size为申请的字节数virtual void *alloc(int size);//释放先前申请的内存virtual void free(void *memblock);protected:struct Mem_Ctrl_Block{    int reserved;    int size;    void *next;    //按地址顺序指向下一个Mem_Ctrl_Block};void *memory_to_manage;int size_to_manage;bool memory_need_free;//指向第一块已分配的内存Mem_Ctrl_Block *first_mem_block;//指向最后一块已分配的内存Mem_Ctrl_Block *last_mem_block;}

 

内存管理类的实现

MemoryManagerImpl::MemoryManagerImpl(){    memory_to_manage = NULL;    size_to_manage = 0;    first_mem_block = NULL;    last_mem_block = NULL;    memory_need_free = false;}MemoryManagerImpl::~MemoryManagerImpl(){    if (memory_need_free)        ::free(memory_to_manage);}void MemoryManagerImpl::setManagedMemory(int size, void *memory){    if (memory == NULL)    {        memory_to_manage = ::malloc(size);        memory_need_free = true;    }    else    {        memory_to_manage = memory;        memory_need_free = false;    }    size_to_manage = size;}int MemoryManagerImpl::getManagedSize() const{    return size_to_manage;}//申请一块内存，size为申请的字节数void *MemoryManagerImpl::alloc(int size){    //在下面的分配实现中，控制节点与返回给用户的内存挨在一起    //（在用户内存的前面就是控制节点）    //检查大小是否合理。这个检查也为了防止计算溢出错误    if (size < 0 || size > size_to_manage)        return NULL;    int need_size = sizeof(Mem_Ctrl_Block) +size;    if (need_size < 0)        return NULL;    if (first_mem_block == NULL)    {        if (need_size <= size_to_manage)        {            first_mem_block = (Mem_Ctrl_Block *)memory_to_manage;            first_mem_block->size = size;            first_mem_block->next = NULL;            last_mem_block = first_mem_block;            return (char *)first_mem_block + sizeof(Mem_Ctrl_Block);        }        else            return NULL;    }    //检查第一个已分配的内存块之前有无足够空闲空间，若有，直接分配    if (first_mem_block != memory_to_manage        && (need_size <= (char *)first_mem_block - (char *)memory_to_manage))    {        Mem_Ctrl_Block *new_first = (Mem_Ctrl_Block *)memory_to_manage;        new_first->size = size;        new_first->next = first_mem_block;        first_mem_block = new_first;        return (char *)first_mem_block + sizeof(Mem_Ctrl_Block);    }    //检查最后一个已分配的内存块之后有无足够空闲空间，若有，直接分配    Mem_Ctrl_Block *after_last = (Mem_Ctrl_Block *)((char *)last_mem_block+ sizeof(Mem_Ctrl_Block) + last_mem_block->size);    if ( need_size <= ((char *)memory_to_manage + size_to_manage - (char *)after_last))    {        //Ok，有足够空闲内存        after_last->size = size;        after_last->next = NULL;        last_mem_block->next = after_last;        last_mem_block = after_last;        return (char *)last_mem_block + sizeof(Mem_Ctrl_Block);    }    //沿着已分配的内存块链表搜索下去，查找两个块中间有足够大的空闲可以分配    Mem_Ctrl_Block *current = first_mem_block;    while (current != last_mem_block)    {        Mem_Ctrl_Block *next_block = (Mem_Ctrl_Block *)current->next;        Mem_Ctrl_Block *after_current = (Mem_Ctrl_Block *)((char *)current+ sizeof(Mem_Ctrl_Block) + current->size);        if (need_size <= (char *)next_block - (char *)after_current)        {            //Ok, 两个已分配块之间有足够的空闲内存，可以分配            after_current->next = next_block;            after_current->size = size;            current->next = after_current;            return (char *)after_current + sizeof(Mem_Ctrl_Block);        }        else            current = next_block;    }    return NULL;}//释放先前申请的内存void MemoryManagerImpl::free(void *memblock){    if (first_mem_block == NULL)        return;    if ((char *)first_mem_block + sizeof(Mem_Ctrl_Block) == memblock)    {        //释放第一个块        Mem_Ctrl_Block *old_first = first_mem_block;        first_mem_block = (Mem_Ctrl_Block *)first_mem_block->next;        old_first->next = NULL;    //这一句为冗余        if (last_mem_block == old_first) last_mem_block = NULL;        return;    }    //沿着已分配的内存块链表搜索下去，直到找到给定的内存块    Mem_Ctrl_Block *current = first_mem_block;    while (current->next)    {        Mem_Ctrl_Block *next = (Mem_Ctrl_Block *)current->next;        if ((char *)next + sizeof(Mem_Ctrl_Block) == memblock)        {            //将内存块节点从链表中删除，完成释放            current->next = next->next;            next->next = NULL;//这一句为冗余            if (last_mem_block == next) last_mem_block = current;            return;        }        current = next;    }}