threadperson.cpp

模拟哲学家就餐过程

#include "stdafx.h"
#include "ThreadCompete.h"
#include "ThreadCollection.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

IMPLEMENT_DYNCREATE(PersonThread, CWinThread)

BEGIN_MESSAGE_MAP(PersonThread, CWinThread)
	//{{AFX_MSG_MAP(PersonThread)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

//这是线程互斥同步所需的变量(方案之一)
CRITICAL_SECTION PersonThread::m_criLock;

// m_hAnotherDead is used to signal that one or more threads have ended
//  (it is an auto-reset event; and starts out not signaled)
// 这是每个线程在退出执行体而EndThread时，广播死亡消息所需要的变量
HANDLE PersonThread::m_hAnotherDead = CreateEvent(NULL, FALSE, FALSE, NULL);

void PersonThread::initPersonThread(CThreadCollection *threads, PERSON_INFO*pPerson)
{	m_pThreads = threads; person = pPerson;  m_bDone=0; 
	m_bAutoDelete = 0;  //我们设置非自动结束方式, 也可以采用自动方式

	// kill event starts out in the signaled state
	m_hEventKill = CreateEvent(NULL, TRUE, FALSE, NULL);	//建立消息句柄
	m_hEventDead = CreateEvent(NULL, TRUE, FALSE, NULL);	//建立消息句柄
}

void PersonThread::Delete()
{	CWinThread::Delete();					//在线程执行体自动结束退出时内部调用
	// acknowledge receipt of kill notification
	VERIFY(SetEvent(m_hEventDead));		//通知自己已处于死亡状态
	VERIFY(SetEvent(m_hAnotherDead));	//广播有线程处于死亡状态
}

PersonThread::~PersonThread()
{
	CloseHandle(m_hEventKill);		//关闭消息句柄，必须与建立配对
	CloseHandle(m_hEventDead);		//关闭消息句柄
}

// 单个线程的杀除: 建立KILL消息句柄 ==> 退出执行体 --> 内部 EndThread() --> delete() ==> 
//                 建立DEAD消息句柄 ==> 等待...dead... ==> 等待可析构 ==> 释放对象
void PersonThread::KillThread()
{	// Note: this function is called in the context of other threads, not the thread itself.
	// reset the m_hEventKill which signals the thread to shutdown
	VERIFY(SetEvent(m_hEventKill));  m_bDone=1;
	// allow thread to run at higher priority during kill process
	SetThreadPriority(THREAD_PRIORITY_ABOVE_NORMAL);

	WaitForSingleObject(m_hEventDead, INFINITE);
	WaitForSingleObject(m_hThread, INFINITE);
	delete this;  //析构释放, now delete CWinThread object since no longer necessary
}

/////////////////////////////////////////////////////////////////////////////
// 注意：A) 三个执行体只是选择一个执行：次序为“之一”、“之二”、“之三”
//		 B) 完成后内部执行 afxEndThread 退出
/////////////////////////////////////////////////////////////////////////////

#define  INSTANCE_LOOP_MODE

// 1、线程执行体之一
//    如果定义了pThread->m_pfnThreadProc，则执行 (*pThread->m_pfnThreadProc)(pThread->m_pThreadParams);

// 2、线程执行体之二
BOOL PersonThread::InitInstance()
{	 CWinThread::InitInstance();
	 m_bDone = (m_pThreads == NULL)? 1: 0; int ret;

#ifdef  INSTANCE_LOOP_MODE
	 //可以在此安排线程执行体，并使返回FALSE，例如：
	 while (1){
		ret = (WaitForSingleObject(m_hEventKill, 0)!= WAIT_TIMEOUT);
		if(ret || m_bDone) break; //没有时间没有超长，则说明被杀了
		ThreadSingleStepRun();  
	 }
	 return false;  //如果返回 FALSE 执行ExitInstance, 给出返回码
#else
	 return true;   //如果返回 TRUE 则执行 Run()
#endif
}

// 3、线程执行体之三： 
int PersonThread::Run()
{
	if (m_pThreads == NULL)return -1;

#ifndef INSTANCE_LOOP_MODE
	 m_bDone = 0;
	 while (1){
		int ret = (WaitForSingleObject(m_hEventKill, 0)!= WAIT_TIMEOUT);
		if(ret || m_bDone) break; //没有时间没有超长，则说明被杀了
		ThreadSingleStepRun();  
	 }

	return 0; ////返回退出码： 退出后执行 afxEndThread(), 如果m_bAutoDelete=1 则自动结束线程
#endif

    return 0;
}

/////////////////////////////////////////////////////////////////////////////

void PersonThread::ThreadSingleStepRun()
{
	int isSomeOneCatch, isSomeBlock, oldStatus, result=0; bool bFirstOne=false,bStarting=false;
	if (m_pThreads == NULL) return ;

	CSingleLock sLock( (CSyncObject*)&(m_pThreads->m_mutex) );
	if (m_pThreads->fSyncChecked)sLock.Lock(); 
	  //临界区代码
	  person->status = CheckPersonStatus(oldStatus);
	  isSomeOneCatch = m_pThreads->CheckPersonCatchStatus(CATCHING);
	  isSomeBlock    = m_pThreads->CheckPersonCatchStatus(BLOCK);

      if(person->status==BEGINEATING && !isSomeOneCatch ){//一轮竞争结束时
	      bFirstOne = m_pThreads->m_step==person->step;
		  bStarting = (m_pThreads->nContinousPrompt == -1);//复位?
		  if(isSomeBlock && bFirstOne && bStarting){       //如果有人没得餐具又无提示，则第一人时提示
			  m_pThreads->StatCompetePersons();
			  m_pThreads->PromptContinousCheckBox(SW_SHOW);//提示后就在该第一人处等待提示消失 
			  while(m_pThreads->nContinousPrompt==SW_SHOW)Sleep(10);//提示消失时开始就餐，//延时后放下 
			  m_pThreads->m_step++;
			  m_pThreads->PromptContinousCheckBox(-1); //复位准备下一轮
		  }
	  }else bStarting=false;
	if (m_pThreads->fSyncChecked) sLock.Unlock();

	switch(person->status){
		case CATCHING:    {	result = CatchDinnerToolkit();	break; } //临界区代码
		case BEGINEATING: { 
			if(bStarting){ //已无人正在取物....
				DelayStepTime( m_bDone );	m_bDone=true; //延时后放下 
				if (m_pThreads->fSyncChecked)sLock.Lock();
				    //临界区代码
					PutdownDinnerToolkit(); 
				if (m_pThreads->fSyncChecked) sLock.Unlock();
			}
			break; }
		case BLOCK:	break;
	}
	
	// A call to Sleep() here tells the system that we want to relinquis 
	// the remainder of our time slice to another thread. this call is needed   
	// for single-CPU systems so that the results of the synchronization or 
	// lack thereof are obvious. Normally, your programs would NOT call Sleep() here.
	if(person->status != FINISHDOWN) Sleep(3000); //适当大些显示效果好些 (>=0)
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

void  PersonThread::DelayStepTime(BOOL bDone)
{
	Sleep( 10*person->steptime);
/*
	time_t now = time(&now);
	while (!bDone){
		time_t ntime = time(&ntime) - now;   //时间差
		if( ntime > (TIME_BASE * person->steptime) )  break; 
		Sleep(10);	}
*/
}

int  PersonThread::CheckOneToolkit(int index, int kf, int upper)
{	 if( !(person->tools & kf) ){
		 for(int left=1; left>=0; left--){	//方位：左或右
		     int lr = (left==1) ? index: ( (index==0)?  upper: index-1 ) ;
			 if( (m_pThreads->dinnerToolArr[lr]&kf) ){
				  return CATCHING; }//手中缺刀叉，但桌上相应位置也有刀叉---可取
		}//for
		return BLOCK;
	 }//if
	 return BEGINEATING;
}

int  PersonThread::CheckPersonStatus(int &oldstatus)
{	 int status, upper, kf=KNIFE_BIT;  oldstatus = person->status; 
	 if(oldstatus==FINISHDOWN)return FINISHDOWN;

	 upper = m_pThreads->GetItemsUpper();
	 if( person->tools!=(KNIFE_BIT|FORK_BIT) ) { //工具：刀或叉
		 if( !(person->tools & KNIFE_BIT) ){
			status = CheckOneToolkit(person->index, KNIFE_BIT, upper);
			if(status==CATCHING) return CATCHING; }//手中缺刀，但桌上相应位置也有刀---可取 

		 if( !(person->tools & FORK_BIT) ){
			status = CheckOneToolkit(person->index, FORK_BIT, upper);
			if(status==CATCHING) return CATCHING; }//手中缺叉，但桌上相应位置也有叉---可取 
	 }else return BEGINEATING;		//手中有刀叉---完成
	 return BLOCK;
}

void PersonThread::PutdownDinnerToolkit( )
{	
	person->status = FINISHDOWN;
	if(person->tools & KNIFE_BIT){    //放回原地
		m_pThreads->PutdownDinnerToolkit(person, KNIFE_BIT, KNIFE_MASK);
	}
	if(person->tools & FORK_BIT){     //放回原地
		m_pThreads->PutdownDinnerToolkit(person, FORK_BIT, FORK_MASK);
	}

	if(m_pThreads && m_pThreads->m_pWnd && m_pThreads->CheckPersonFinishStatus()){
		int upper = m_pThreads->GetItemsUpper(); upper = (upper<0)?0: (upper+1);
		person->message.Format("The %d persons to ending...", upper);
		m_pThreads->UpdateNotify( person );
		m_pThreads->m_pWnd->SendMessage(WM_USER_NOTIFY,upper,0);
	}
}

// ........ 适当修改此函数，可以得到不同的算法效果.............

int PersonThread::CatchDinnerToolkit( )
{	//如果“餐具”和“方向”非完全随机，则算法有倾向性
	//另外如果各线程的优先级不同或每人的 steptime 不同，则算法更有倾向性
	bool isFork, fromLeft;
	if((person->tools & KNIFE_BIT)||(person->tools & FORK_BIT)){ 
		isFork = ((person->tools & FORK_BIT)>0) ? false : true;
	}else{ for(int i=0; i<= person->index; i++) rand(); isFork = rand()&1; } //空手？

	for(int i=0; i<= person->index; i++) rand();  fromLeft =  rand()&1;

    person->step = m_pThreads->m_step;
	if (m_pThreads->fSyncChecked) EnterCriticalSection(&PersonThread::m_criLock);
	  int result = m_pThreads->CatchDinnerToolkit( person, fromLeft, isFork);  //取走刀或叉
	  //一侧没取到则在另一侧取一下, 当然此句可省略
	  if(!result)result = m_pThreads->CatchDinnerToolkit( person, !fromLeft, isFork); 
	if (m_pThreads->fSyncChecked) LeaveCriticalSection(&PersonThread::m_criLock);

	return result;
}