引擎之旅 Chapter.2 线程库

预备知识可参考我整理的博客

• Windows编程之线程:https://www.cnblogs.com/ZhuSenlin/p/16662075.html
• Windows编程之线程同步:https://www.cnblogs.com/ZhuSenlin/p/16663055.html

目录

• 代码结构
• 线程同步的实现
  • 原子函数与关键段
    • Interlocked家族函数的封装
    • 关键段的封装
  • 内核对象的同步方式
    • 代码结构
    • SyncKernelObject基类
    • SyncTrigger
    • SyncTimer
    • SyncSemaphore
    • SyncMutex
• 线程类的实现
• 结语

代码结构

一个简单的线程库需要实现的功能主要有：

• 创建和结束一个线程
• 设置线程的优先级
• 提供一些线程调度的接口
• 查询线程的状态
• 退出一个线程
• 多线程运行时同步的解决方案
• 线程池（非必要）：多用于网络请求、单一且快速能解决的任务。

利用C++类的生命周期，，我们可以实现一个线程的创建放在构造函数上,结束放在析构函数上。当想要实现一个特殊线程时，就采用继承的方式拓展这个线程类。

• 一个基本的类框架如下

//Thread.h     线程基类
class Thread
{
    public:
        Thread()
        {
            //Create a thread
            //函数入口为：ThreadMain((void)this);
        }
        
        ~Thread()
        {
            //Terminate a thread
        }
        
    
    protected:
        //线程执行的纯虚函数，子类重写这个函数来说明线程需要执行的任务
        virtual int Run()=0;  
        
    private:
        //此函数会调用(Thread*)param->Run();
        static unsigned _stdcall ThreadMain(void* param);
}


//ThreadSync.h    线程同步的方式
//1.原子操作函数
//2.关键段
//3.事件内核对象
//4.可等待的计时器内核对象
//5.信号量内核对象
//6.互斥量内核对象

线程同步的实现

首先我们要明确的一点是：用户方式的线程同步较为简单且独立，仅作稍微的封装为引擎统一风格的代码即可；而对象内核的同步方式是比较统一的，它们的阻塞与恢复是由等待函数(WaitForSingleObject或WaitForMultipleObjects)来实现的，引起它们其实可以统一为一种类型。

原子函数与关键段

用户方式的线程同步比较简单，Windows API也给的比较清楚，下面是相关的代码展示。

Interlocked家族函数的封装

• 代码

//原子操作：++
//*pValue++
FORCEINLINE void TInterlockedIncrement(unsigned long long* pValue)
{
	::InterlockedIncrement(pValue);

//原子操作：--
//*pValue--
FORCEINLINE void TInterlockedDecrement(unsigned long long* pValue)
{
	::InterlockedDecrement(pValue);

//原子操作：+=
//*added+=addNum
FORCEINLINE void TInterlockedExchangeAdd(PLONG added, LONG addNum)
{
	::InterlockedExchangeAdd(added, addNum);

//原子操作：-=
//*added-=addNum
FORCEINLINE void TInterlockedExchangeSub(PULONG subed, LONG subNum)
{
	::InterlockedExchangeSubtract(subed, subNum);

//原子操作：=
//target=lvalue;
FORCEINLINE LONG TInterlockedExchange(PLONG target, LONG value)
{
	return ::InterlockedExchange(target, value);

//原子操作：=
//pTarget=&pVal
FORCEINLINE PVOID TInterlockedExchangePointer(PVOID* pTarget, PVOID pVal)
{
	return ::InterlockedExchangePointer(pTarget, pVal);

//原子操作：
//if(*pDest==compare)
//  *pDest=value;
FORCEINLINE LONG TInterlockedCompareExchange(PLONG pDest, LONG value, LONG compare)
{
	return ::InterlockedCompareExchange(pDest, value, compare);

//原子操作：
//if(*pDest==pCompare)
//  pDest=&value;
FORCEINLINE PVOID TInterlockedCompareExchangePointer(PVOID* ppDest, PVOID value, PVOIpCompare)
{
	//如果ppvDestination和pvCompare相同，则执行ppvDestination=pvExchange，否则不变
	return ::InterlockedCompareExchangePointer(ppDest, value, pCompare);
}

其实上面的代码就是将Windows API 修改了函数命名。我个人认为，这种写代码的方式是有益处。因为线程库这一块的代码是较为底层的部分，如果上层直接调用API，一旦遇到了Windows API过时等问题导致的实现方式要修改的情况，你就需要一个项目一个项目的去修改名称，这是不严谨的。代码的底层要尽可能地隐藏代码的实现部分，仅提供功能接口。

• 用例:两个线程同时对一个变量进行++操作

int m_gCount=0;    //全局变量

class Thread1 : public Thread
{
    //...
    
    virtual int Run()
    {
        TInterlockedIncrement(&((unsigned long long)m_gCount));
    }
}

class Thread2 : public Thread
{
    //...
    
    virtual int Run()
    {
        TInterlockedIncrement(&((unsigned long long)m_gCount));
    }
}

关键段的封装

• 代码

//Defines [.h]
//-----------------------------------------------------------------------
class TURBO_CORE_API CriticalSection
{
    public:
        CriticalSection();   //初始化关键段变量
	    ~CriticalSection();  //删除关键段变量
	    
	    //挂起式关键段访问：即若有其他线程访问时，则调用处会挂起等待
	    inline void Lock();
		//结束访问关键段
		inline void Unlock();
		//非挂起式关键段访问
		//若有其他线程访问此关键段，则返回FALSE。可以访问则放回TRUE
		inline bool TryLock();
		
	private:
		CRITICAL_SECTION m_cs;
}

//implement[.cpp]
//-----------------------------------------------------------------------
TurboEngine::Core::CriticalSection::CriticalSection()
{
	::InitializeCriticalSection(&m_cs);
}

TurboEngine::Core::CriticalSection::~CriticalSection()
{
	::DeleteCriticalSection(&m_cs);
}

inline void TurboEngine::Core::CriticalSection::Lock()
{
	::EnterCriticalSection(&m_cs);
}

inline void TurboEngine::Core::CriticalSection::Unlock()
{
	::LeaveCriticalSection(&m_cs);
}

inline bool TurboEngine::Core::CriticalSection::TryLock()
{
	return ::TryEnterCriticalSection(&m_cs);
}

inline void TurboEngine::Core::CriticalSection::SetSpinCount(DWORD dwSpinCount)
{
	::SetCriticalSectionSpinCount(&m_cs, dwSpinCount);
}

• 用例:两个线程同时对一个变量进行++操

CriticalSection m_cs;
int m_gCount=0;

class Thread1 : public Thread
{
    //...
    
    virtual int Run()
    {
        m_cs.Lock();  //若有其他线程访问m_gCount则线程挂起等待
        m_gCount++;
        m_cs.Unlock();
    }
}

class Thread2 : public Thread
{
    //...
    
    virtual int Run()
    {
        if(m_cs.TryLock())
        {
            m_gCount++;
            m_cs.Unlock();
        }
    }
}

内核对象的同步方式

代码结构

• SyncKernelObject
  • SyncTrigger
  • SyncTimer
  • SyncSemaphore
  • SyncMutex

SyncKernelObject基类

基类理所应当的封装了线程同步内核对象所需要的一些变量和函数。我们都知道，对于所有的同步内核对象，实现同步都依赖与Wait函数，因此，我也把Wait函数封装在了父类上。基类的代码如下所示：

//Defines [.h]
//-----------------------------------------------------------------------------------------------------------------------
class TURBO_CORE_API SyncKernelObject
{
    public:
        //等待得状态
        enum WaitState : DWORD
	    {
	    	Abandoned = WAIT_ABANDONED,      //占用此内核对象的线程突然被终止时，其他等待的线程中的其中一个会收到WAIT_ABANDONED
	    	Active = WAIT_OBJECT_0,      //等待的对象被触发
	    	TimeOut = WAIT_TIMEOUT,      //等待超时
	    	Failded = WAIT_FAILED,       //给WaitForSingleObject传入了无效参数
	    	Null = Failded - 1           //占用了一个似乎没有相关值得变量表示句柄为NULL（Failed-1）
	    };
	
	public:
			SyncKernelObject(PSECURITY_ATTRIBUTES psa = NULL, LPCWSTR objName = NULL);
			~SyncKernelObject();

	public:
		//获取内核对象的句柄
		inline HANDLE GetHandle() { return m_KernelObjHandle; }
		//获取内核对象的名称
		inline const LPCWSTR GetName()   { return m_Name; }
		//获取内核对象的安全性结构体
		inline PSECURITY_ATTRIBUTES GetPsa() { return m_psa; }
		//(静态函数)多个内核对象的等待函数
		inline static DWORD Waits(DWORD objCount, CONST HANDLE* pObjects, BOOL waitAll, DWORDwaitMilliSeconds)
		{
			return WaitForMultipleObjects(objCount, pObjects, waitAll, waitMilliSeconds);
		}


	protected:
		//自身相关的等待函数
		WaitState Wait(DWORD milliSeconds);
	
	protected:
	    HANDLE  m_KernelObjHandle;    //内核对象句柄
	    LPCWSTR m_Name;               //内核对象名称，默认为NULL
	    PSECURITY_ATTRIBUTES m_psa;   //安全性相关得结构体，通常为NULL
}

SyncTrigger

事件内核对象。我更愿意称它为触发器、开关。作为一个触发器，它存在激活与非激活两种状态，我们可以利用这种状态灵活的控制线程同步问题。

//Defines [.h]
class TURBO_CORE_API SyncTrigger : public SyncKernelObject
{
public:
	SyncTrigger(bool bManual, bool isInitialActive, LPCWSTR objName = NULLPSECURITY_ATTRIBUTES psa = NULL);
	~SyncTrigger()
	
	//时间内核对象的等待函数（调用父类的Wait函数）
	WaitState CheckWait(DWORD waitMilliSeconds)
	
	//当前是否为激活状态
	bool IsTrigger();
	
	//设置当前状态为激活
	bool SetActive();
	
	//设置当前状态为未激活
	bool SetInactive();
};

• 函数解析：
  • SyncTrigger:唯一构造函数。bManual为是否是手动重置，isInitialActive为初始激活的状态。
  • CheckWait：常规的内核对象Wait函数
  • IsTrigger：等待时间为0的Wait函数，用于获取当前Trigger的触发状态
  • SetActive:将Trigger设置为触发状态
  • SetInactive：Trigger设置为非触发状态
• 用例

//利用触发器作为线程退出的标记（可以避免强行终止线程的操作）

SyncTrigger m_Trigger(true,false);  //手动重置、初始状态为非激活的触发器
//某个线程的入口函数
virtual DWORD WINAPI Run()
{
    //若此触发器未激活，则持续循环
    while(!m_Trigger.IsTrigger())
    {
        //TO-DO
    }
    
    //退出线程
    return 0;
}

//当需要退出该线程时，可以调用如下，线程可跳出执行的循环
m_Trigger.SetActive();  //激活此触发器

SyncTimer

计时器内核对象顾名思义，就是和时间相关的控制器。当SyncTimer的内核对象设置为自动重置时，此计时器可以周期性的设置内核对象为激活状态，这就是SyncTimer的主要功能。类的属性和函数如下所示：

class TURBO_CORE_API SyncTimer : public SyncKernelObject
{
public:
	SyncTimer(bool bManual, LPCWSTR objName = NULL, PSECURITY_ATTRIBUTES psa = NULL);
	~SyncTimer()
	//内核对象的等待函数（调用父类的Wait函数）
	WaitState CheckWait(DWORD waitMilliSeconds);
	
	//当前是否为激活状态
	bool IsTrigger();
	
	//开始计时器
	bool StartTimer(const LARGE_INTEGER* startTime, LONG circleMilliSeconds);
	
	//取消计时器
	bool CancelTimer();
};

• 函数简析
  • SyncTimer：唯一构造函数。bManual为是否是手动重置
  • CheckWait：常规的内核对象Wait函数
  • IsTrigger：等待时间为0的Wait函数，用于获取当前Trigger的触发状态
  • StartTimer：startTime为起始的事件，具体如何赋值可以参考MSDN文档；circleMilliSeconds为周期触发的时 长（毫秒）。注意：此参数只有在内核对象为自动重置模式才有意义。
  • CancelTimer：取消开始的计时器
• 用例

//每秒钟SyncTimer激活一次的程序代码

SyncTimer m_gSyncTimer(false);   //自动重置的计时器内核对象

//某个线程的入口函数
virtual DWORD WINAPI Run()
{
    //若此触发器未激活，则持续循环
    while(!m_Trigger.IsTrigger())
    {
        //使用计时器
        if (m_gSyncTimer.IsTrigger())
		    cout << "SyncTimer激发一次\n";
    }
    
    //退出线程
    return 0;
}


//注意startTime的参数如何编写：
LARGE_INTEGER liDueTime;
liDueTime.QuadPart = 0;
m_gSyncTimer.StartTimer(&liDueTime, 1000);  //设定计时器为1S钟激活一次

startTime:如果值是正的，代表一个特定的时刻。如果值是负的，代表以100纳秒为单位的相对时间

SyncSemaphore

class TURBO_CORE_API SyncSemaphore : public SyncKernelObject
{
public:
	SyncSemaphore(LONG initialCount, LONG maximumCount, LPCWSTR objName = NULLPSECURITY_ATTRIBUTES psa = NULL);
	~SyncSemaphore();
	
	//申请使用一个资源(此时的引用计数将会减1)
	WaitState Lock(DWORD dwMilliseconds);
	
	//释放一个资源
	//releaseCount：释放的数量
	//oldResCount：未释放前资源的数量
	bool Unlock(DWORD releaseCount = 1, LPLONG oldResCount = NULL);
};

• 函数简析
  • SyncSemaphore: 唯一构造函数。initialCount：资源创建后立即占用的数量；maximumCount内核对象管理资源的最大数量
  • Lock：申请使用一个资源
  • Unlock：释放资源

SyncMutex

//互斥内核对象
//可以理解为内核对象版的关键段
class TURBO_CORE_API SyncMutex : public SyncKernelObject
{
public:
	SyncMutex(bool initialOccupied, LPCWSTR objName = NULL, PSECURITY_ATTRIBUTES psa NULL);
	~SyncMutex();
	
	//挂起式申请访问（若申请访问的变量被占用时则线程挂起）
	void Lock();
	
	//结束访问
	bool Unlock();
	
	//非挂起式访问
	//若有其他线程访问此关键段，则返回FALSE。可以访问则放回TRUE
	bool TryLock(DWORD milliSeconds=0);
};

• 函数简析（略），和关键段功能相同
• 用例

//Run1()和Run2()不会发生访问冲突而引发未知结果

SyncMutex m_gMutex(false);
int  m_gSyncCounter1=0;

//某个线程的入口函数
virtual DWORD WINAPI Run1()
{
//若此触发器未激活，则持续循环
    while(!m_Trigger.IsTrigger())
    {
        if (m_gMutex.TryLock())
        {
            cout << "线程[" << GetThreadId() << "]完成一次累加:[" << m_gSyncCounter1 << "]" << "\n";
            m_gMutex.Unlock();
        }
    }
}

//某个线程的入口函数
virtual DWORD WINAPI Run2()
{
//若此触发器未激活，则持续循环
    while(!m_Trigger.IsTrigger())
    {
        if (m_gMutex.TryLock())
        {
            cout << "线程[" << GetThreadId() << "]完成一次累加:[" << m_gSyncCounter1 << "]" << "\n";
            m_gMutex.Unlock();
        }
    }
}

线程类的实现

上一节我们讲了线程同步的方式，通过编写的线程同步代码。我们使用多线程的时候可以正确的访问一些公共变量。那么关键的线程类我们该如何实现呢。自己对线程理解如下图所示。

相关基类的定义代码如下：

//引擎线程基类
		class TURBO_CORE_API Thread
		{
		public:
			enum class PriorityLevel : int
			{
				TimeCritical = THREAD_PRIORITY_TIME_CRITICAL,
				Highest = THREAD_PRIORITY_HIGHEST,
				AboveNormal = THREAD_PRIORITY_ABOVE_NORMAL,
				Normal = THREAD_PRIORITY_NORMAL,
				BelowNormal = THREAD_PRIORITY_BELOW_NORMAL,
				Lowest = THREAD_PRIORITY_LOWEST,
				Idle = THREAD_PRIORITY_IDLE
			};

			enum class ThreadState
			{
				Initialized,
				Running,
				Suspend,
				Stop,
			};

		public:
			//线程构造函数
			//priorityLevel:线程优先级，默认为<normal>
			//stackSize:线程的堆栈大小，默认为<0>
			Thread(PriorityLevel priorityLevel = PriorityLevel::Normal, unsigned int stackSize = 0);
			~Thread();

			//开启线程
			void Start();

			//挂起线程
			//return->返回挂起前的挂起计数
			int Suspend();

			//恢复线程。
			//[注意，恢复一次不一定会立即执行]
			//return->返回恢复前的挂起系数
			int Resume();

			//终止线程
			bool Stop();
			
			//是否允许动态提升优先级
			//Notes:在当前优先级的范围内各个切片时间上下浮动，但不会跳到下一个优先级
			//当前的优先级是一个优先级范围，而不是具体的等级
			bool IsAllowDynamicPriority();

			//启用or禁止动态提升优先级
			bool SetPriorityBoost(bool bActive);

			//设置线程优先级
			bool SetPriority(PriorityLevel priority);

			//当前线程的优先级
			PriorityLevel GetCurrentPriority();

			//线程是否存在
			bool IsAlive();

			//当前线程的状态
			ThreadState GetCurrentState();

			//获取线程Id
			DWORD GetThreadId();

			//线程名称
			virtual const CHAR* ThreadName() = 0;

		protected:
			//线程的主逻辑函数
			virtual DWORD WINAPI Run() = 0;

			//线程函数入口
			static unsigned _stdcall ThreadEnterProc(void* param);

		protected:
			HANDLE        m_ThreadHandle = NULL;     //线程句柄
			unsigned int  m_ThreadStackSize = 0;     //线程堆栈大小
			ThreadState   m_CurrentState;            //当前线程的状态
			PriorityLevel m_CurrentPriority;         //当前线程的优先级
			SyncTrigger   m_TerminateThreadTrigger;  //终止线程的触发器
		};
	}

具体如何是实现，如果说熟悉Windows提供的线程API，我想很快就能实现。那么如何开启一个线程呢。既然上面的基类基本实现了对一个线程创建、销毁、调度的函数。那么每个线程的差异点应该在两个虚函数上。

//定义线程名称的位置
virtual const CHAR* ThreadName() = 0;

//线程入口函数的实现代码放置的位置
virtual DWORD WINAPI Run() = 0;

• 用例：定义一个渲染线程并开启

class RenderThread : public Thread
{
public:
    virtual const CHAR* ThreadName()
    {
        return "RenderThread";
    }

protected:
    virtual DWORD WINAPI Run()
    {
        //StartRender
        while(!gameStop)
        {
            RenderOpaque();
            RenderTransparent();
            //...
        }
    }
}

//开启渲染线程
RenderThread m_gRenderThread;
m_gRenderThread.Start();

结语

上面的线程类和线程同步类共同构成了引擎简单的线程库。当然，真正可用的游戏引擎，其线程库不可能这么简单，但是，对于目前而言，这也足够使用。

碍于篇幅，很多代码仅提供了类的定义，关于类的实现，请参考Github上的项目。