unibus.cpp

一个多线程

			case EVT_WORK_TIMER:
				try{
					OnTimer(pMsg->m_ierror,pMsg->m_dwIdent);
				}
				catch(...){}
				break;
			case EVT_CMD_LOCKSCS:
				try{
					OnLockSuccess((HANDLE)pMsg->m_pTV[0],(CAsynWorker *)(void *)pMsg->m_pTV[1],(DWORD)pMsg->m_pTV[2]);
				}
				catch(...){}
				break;
			case EVT_EXCUTE_REMOTE:
				{
					try{
						if(pMsg->m_iNumOfTV>=1){
							if(LINE_CONTINUE==ExcuteDirect((DWORD)pMsg->m_pTV[0],(DWORD)pMsg->m_pSender,pMsg->m_dwSendMode,pMsg->m_iNumOfTV-1,pMsg->m_pTV+1)){
								CUniMsg um;
								um.SetMessage(GetModId(),pMsg->m_dwSendMode,this,pMsg->m_pSender,EVT_EXCUTE_OVER,MSG_EVENT,InValidVar);
								for(int i=0;i<pMsg->m_iNumOfTV;i++){
									um.Add(pMsg->m_pTV[i]);
								}
								m_pBus->SendMessage(&um);
							}
						}
						else{
							//error don't know why?
						}
					}
					catch(...){}
				}
				break;
			case EVT_EXCUTE_OVER:
				{
					try{
						if(pMsg->m_iNumOfTV>=1){
							OnExcuteOver(pMsg->m_ierror,(DWORD)pMsg->m_pTV[0],pMsg->m_pTV+1,pMsg->m_iNumOfTV-1);
						}
						else {
							//error,don't know why?
						}
					}
					catch(...){}
				}
				break;
			case EVT_WORK_CANCEL:
				{
					if(m_pCmdReceive){
						if(m_pCmdReceive->m_btMsgType==MSG_COMMAND){
							if(m_pCmdReceive->m_dwIdent==pMsg->m_dwIdent){
								CUniMsg * pTempMsg=m_pCmdSend;
								m_pCmdReceive=NULL;
								try{
									OnEvtCancel(pTempMsg);
								}
								catch(...){}
								delete pTempMsg;
							}
						}
					}
				}
				break;
			case EVT_CMD_TIMEOUT:
			case EVT_CMD_STOPCMD:
			case EVT_CMD_BUSYCMD:
			case EVT_CMD_VALIDRSV:
				if(m_pCmdSend){
					if(m_pCmdSend->m_btMsgType==MSG_COMMAND){
						if(m_pCmdSend->m_dwIdent==pMsg->m_dwIdent){
							CUniMsg * pTempMsg=m_pCmdSend;
							CUniMsg um;
							memcpy(&um,m_pCmdSend,sizeof(CUniMsg));
							um.m_pTV=NULL;
							um.m_btMsgType=MSG_RESPONSE;
							um.m_iNumOfTV=0;
							um.m_pReceivor=m_pCmdSend->m_pSender;
							um.m_pSender=m_pCmdSend->m_pReceivor;
							um.m_dwSendMode=m_pCmdSend->m_dwReceiveMode;
							um.m_dwReceiveMode=m_pCmdSend->m_dwSendMode;
							switch(pMsg->m_dwCommand){
							case EVT_CMD_TIMEOUT:
								um.m_ierror=-100;
								break;
							case EVT_CMD_STOPCMD:
								um.m_ierror=-101;
								break;
							case EVT_CMD_BUSYCMD:
								um.m_ierror=-102;
								break;
							case EVT_CMD_VALIDRSV:
								um.m_ierror=-103;
								break;
							}
							m_pCmdSend=NULL;
							if(pTempMsg->m_btIsTimeLimited)
								m_pBus->CancelTime(this,pTempMsg->m_dwIdent,true);
							try{
								OnMsgResp(pMsg,pTempMsg);
							}
							catch(...){
							}
							delete pTempMsg;
						}
					}
				}
				break;
			default:
				OnMsgEvent(pMsg);
				break;
			}
		}
		catch(...){
		}
	}
	return ;
};

void CAsynWorker::CancelCommand(){
	if(!m_pBus)return ;
	if(!m_pCmdSend)return;
	if(m_pCmdSend->m_btMsgType!=MSG_COMMAND)return;
	CUniMsg * pTempMsg=m_pCmdSend;
	m_pCmdSend=NULL;
	if(pTempMsg->m_btIsTimeLimited==1)
		m_pBus->CancelTime(this,pTempMsg->m_dwIdent,true);
	m_pBus->CancelCmd(pTempMsg);
	delete pTempMsg;
	return ;
};

void CAsynWorker::StopResponse(){
	if(!m_pBus)return ;
	if(!m_pCmdReceive)return;
	if(m_pCmdReceive->m_btMsgType!=MSG_COMMAND)return;
	CUniMsg * pTempMsg=m_pCmdReceive;
	m_pCmdReceive=NULL;
	CUniMsg um;
	um.SetMessage(0,pTempMsg->m_dwSendMode,this,pTempMsg->m_pSender,EVT_CMD_STOPCMD,MSG_EVENT,
		InValidVar
		);
	um.m_dwIdent=pTempMsg->m_dwIdent;
	m_pBus->SendMessage(&um,pTempMsg->m_btBusRoad);
	delete pTempMsg;
	return ;
};
void CAsynWorker::OnMsgCmd(CUniMsg * pMsg)
{
	SendResp(pMsg->m_dwSendMode,pMsg->m_pSender,pMsg->m_dwCommand);
}

void CAsynWorker::AddTime(int iNumTimeflake,DWORD dwIdent,bool bDirectCall,bool bForeverCall,bool bTimeRoad)
{
	if(!m_pBus)return ;
	m_pBus->AddTime(this,iNumTimeflake,dwIdent,bDirectCall,bForeverCall,false,bTimeRoad);
};

void CAsynWorker::LogEvent(LOGTYPE logtype,int icommand,int ilevel,char * lpszdescripe,char * lpLogFileName)
{
	if(!m_pBus)return ;
	m_pBus->LogEvent(logtype,icommand,ilevel,lpszdescripe,lpLogFileName);
};

void CAsynWorker::ResetTime(DWORD dwIdent)
{
	if(!m_pBus)return ;
	m_pBus->ResetTime(this,dwIdent);
}

void CAsynWorker::CancelTime(DWORD dwIdent)
{
	if(!m_pBus)return ;
	m_pBus->CancelTime(this,dwIdent);
};

long CAsynWorker::GetTimeStamp()
{
	if(!m_pBus)return 0;
	return m_pBus->GetTimeStamp();
};

BOOL CAsynWorker::IsLocked(CAsynWorker * pWorker)
{
	if(!m_pBus)return FALSE;
	if(pWorker==NULL)pWorker=this;
	return m_pBus->IsLocked(pWorker);
}
void CAsynWorker::ProcSynMsg(CUniMsg * pOMsg)
{
	if(pOMsg->m_dwSendMode==0||pOMsg->m_dwSendMode==GetModId()){
		CSynWorker * pSys=(CSynWorker *)pOMsg->m_pSender;
		if(pSys->IsSynWorker()){
			BOOL ret=TRUE;
			try{
				ret=SynMsgProc(pOMsg,pSys->m_pCmdReceive);
			}
			catch(...){
				ret=TRUE;
				pSys->m_pCmdReceive->m_ierror=-2;
			}
			if(ret){
				pSys->SetTaskOver();
			}
		}
		else{
			//error
		}
	}
	else{
		CUniMsg * pMsg=new CUniMsg();
		pMsg->m_btMsgType=MSG_SYNCMD;
		pMsg->m_dwCommand=pOMsg->m_dwCommand;
		pMsg->m_pReceivor=pOMsg->m_pSender;
		pMsg->m_pSender=pOMsg->m_pReceivor;
		pMsg->m_dwSendMode=pOMsg->m_dwReceiveMode;
		pMsg->m_dwReceiveMode=pOMsg->m_dwSendMode;
		pMsg->m_ierror=0;
		BOOL ret=TRUE;
		try{
			ret=SynMsgProc(pOMsg,pMsg);
		}
		catch(...){
			pMsg->m_ierror=-2;
			ret=TRUE;
		}
		if(ret)
			m_pBus->SendMessage(pMsg,(void *)pMsg->m_pReceivor);
		delete pMsg;
	}
}

void CDataBus::ProcSynMsg(CUniMsg * pOMsg)
{
	if(pOMsg->m_dwSendMode==0||pOMsg->m_dwSendMode==GetModId()){
		CSynWorker * pSys=(CSynWorker *)pOMsg->m_pSender;
		if(pSys->IsSynWorker()){
			BOOL ret=TRUE;
			try{
				ret=SynMsgProc(pOMsg,pSys->m_pCmdReceive);
			}
			catch(...){
				pSys->m_pCmdReceive->m_ierror=-2;
				ret=TRUE;
			}
			if(ret)
				pSys->SetTaskOver();
		}
		else{
			//error
		}
	}
	else{
		CUniMsg * pMsg=new CUniMsg();
		pMsg->m_btMsgType=MSG_SYNCMD;
		pMsg->m_dwCommand=pOMsg->m_dwCommand;
		pMsg->m_pReceivor=pOMsg->m_pSender;
		pMsg->m_pSender=pOMsg->m_pReceivor;
		pMsg->m_dwSendMode=pOMsg->m_dwReceiveMode;
		pMsg->m_dwReceiveMode=pOMsg->m_dwSendMode;
		pMsg->m_ierror=0;
		BOOL ret=TRUE;
		try{
			ret=SynMsgProc(pOMsg,pMsg);
		}
		catch(...){
			pMsg->m_ierror=-2;
			ret=TRUE;
		}
		if(ret)
			SendMessage(pMsg,(void *)pMsg->m_pReceivor);
		delete pMsg;
	}
}

UINT BusRoad::Drive(LPVOID lpVoid)
{
	BusRoad * pRoad=(BusRoad *)lpVoid;
	if(!pRoad->IsValid()){
		TRACE("invalid thread:%lx\n",pRoad);
		return 0;
	}
	try{
		if(pRoad->m_pCurMsg)
			delete pRoad->m_pCurMsg;
		pRoad->m_pCurMsg=NULL;
	}
	catch(...){
	}
	int iOutLoop=0;
	CoInitialize(NULL);
	try{
		while(1){
			pRoad->m_iStatus=THREAD_STATUS_WAIT;
			WaitForMultipleObjects(2,&pRoad->m_pData->m_hMutex,TRUE,INFINITE);
			if(pRoad->m_pData->m_bExit){
				if(pRoad->m_pData->m_btExitThread!=pRoad->m_iRoad){
					ReleaseMutex(pRoad->m_pData->m_hMutex);
					iOutLoop++;
					//here must have a count limited,or it will appear a dead lock
					if(iOutLoop>2000){
					}
					else{
						ReleaseSemaphore(pRoad->m_pData->m_hSemaphore,1,NULL);
						Sleep(10);
					}
					continue;
				}
				ReleaseMutex(pRoad->m_pData->m_hMutex);
//				TRACE("road exit \n");
				CoUninitialize();
				return 0;
			}
			try{
				pRoad->m_pCurMsg=pRoad->m_pData->m_ListMsg.RemoveHead();
				if(pRoad->m_pCurMsg->m_pReceivor){
					if(pRoad->m_pCurMsg->m_pReceivor->m_btCurRoad&&pRoad->m_pBus->m_pRoad[pRoad->m_pCurMsg->m_pReceivor->m_btCurRoad]->m_pOwnMsg){
						pRoad->m_pBus->m_pRoad[pRoad->m_pCurMsg->m_pReceivor->m_btCurRoad]->m_pOwnMsg->Add(pRoad->m_pCurMsg);
						ReleaseMutex(pRoad->m_pData->m_hMutex);
						pRoad->m_pCurMsg=NULL;
						continue;
					}
					else{
						pRoad->m_pCurMsg->m_pReceivor->m_btCurRoad=pRoad->m_iRoad;
					}
				}
			}
			catch(...){
			}
			ReleaseMutex(pRoad->m_pData->m_hMutex);
			while(pRoad->m_pCurMsg){
				pRoad->m_iStatus=THREAD_STATUS_WORK;
				pRoad->m_pData->m_iGetOffNum++;
				if(pRoad->m_pCurMsg->m_btMsgType==MSG_SYNCMD){
					if(pRoad->m_pCurMsg->m_dwCommand==EVENT_RUN_TASK){
						CUserControl * pC=(CUserControl *)pRoad->m_pCurMsg->m_pReceivor;
						if(pC->ControlValid()){
							if(pC->m_pControl){
								WaitForSingleObject(pRoad->m_hFlowMutex,INFINITE);
								try{
									pC->m_pControl->RunTask();
								}
								catch(...){
								}
								ReleaseMutex(pRoad->m_hFlowMutex);
							}
						}
					}
					else{
						try{
							if(pRoad->m_pCurMsg->m_pReceivor){
								if(!pRoad->m_pCurMsg->m_pReceivor->IsValid()){
									pRoad->m_pCurMsg->m_pReceivor=pRoad->m_pBus->GetRegisterObject((int)pRoad->m_pCurMsg->m_pReceivor);
								}
							}
							if(pRoad->m_pCurMsg->m_pReceivor->IsValid()){
								pRoad->m_pCurMsg->m_pReceivor->ProcSynMsg(pRoad->m_pCurMsg);
							}
							else{
								pRoad->m_pBus->ProcSynMsg(pRoad->m_pCurMsg);
							}
						}
						catch(...){
						}
					}
				}
				else {
					if(pRoad->m_pCurMsg->m_pReceivor){
						if(!pRoad->m_pCurMsg->m_pReceivor->IsValid()){
							pRoad->m_pCurMsg->m_pReceivor=pRoad->m_pBus->GetRegisterObject((int)pRoad->m_pCurMsg->m_pReceivor);
						}
					}
					if(pRoad->m_pCurMsg->m_pReceivor){
						try{
							if(pRoad->m_pBus->TestLock(pRoad->m_pCurMsg)){
								pRoad->m_pCurMsg->m_pReceivor->OnMsgReceive(pRoad->m_pCurMsg);
							}
							else {
								pRoad->m_pCurMsg=NULL;
								continue;
							};
						}
						catch(...){
							CUniMsg um;
							um.m_dwIdent=pRoad->m_pCurMsg->m_dwIdent;
							um.SetMessage(NULL,pRoad->m_pCurMsg->m_pSender,EVT_CMD_VALIDRSV,MSG_EVENT,InValidVar);
							pRoad->m_pBus->SendMessage(&um,NULL);
							CString cs;
							if(!pRoad->m_pCurMsg->m_iNumOfTV)
								cs.Format("exption send:%ld",pRoad->m_pCurMsg->m_dwCommand);
							else
								cs.Format("exption send:%ld,%ld,%ld",pRoad->m_pCurMsg->m_dwCommand,pRoad->m_pCurMsg->m_iNumOfTV,(int)pRoad->m_pCurMsg->m_pTV[0]);
							pRoad->m_pBus->LogEvent(exceptionLog,0,0,(LPSTR)(LPCTSTR)cs,"except.txt");
						}
					}
					else{
						try{
							pRoad->m_pBus->OnBusMsg(pRoad->m_pCurMsg);
						}
						catch(...){
						}
					}
				}
				CUniMsg * pRMsg=pRoad->m_pCurMsg;
				WaitForSingleObject(pRoad->m_pData->m_hMutex,INFINITE);
				try{
				if(pRoad->m_pOwnMsg&&pRoad->m_pOwnMsg->GetSize()){
					pRoad->m_pCurMsg=pRoad->m_pOwnMsg->GetAt(0);
					pRoad->m_pOwnMsg->RemoveAt(0);
				}
				else{
					if(pRoad->m_pCurMsg->m_pReceivor->IsValid()){
						pRoad->m_pCurMsg->m_pReceivor->m_btCurRoad=0;
					}
					pRoad->m_pCurMsg=NULL;
				}
				}
				catch(...){
					TRACE("error\n");
				}
				ReleaseMutex(pRoad->m_pData->m_hMutex);
				try{
					delete pRMsg;
				}
				catch(...){
					TRACE("errorasdfasdf\n");
				};
			}
		}
	}
	catch(...){
		TRACE("road thread exception %lx\n",pRoad);
		if(pRoad->IsValid()){
			pRoad->m_iStatus=THREAD_STATUS_ERROR;
			pRoad->m_iError++;
			pRoad->m_pThread=AfxBeginThread(BusRoad::Drive,(LPVOID)pRoad);
		}
		CoUninitialize();
		return 0;
	}
};

UINT CDataBus::WriteLog(LPVOID lpVoid){
	CDataBus * pCBus=(CDataBus *)lpVoid;
	if(!pCBus->IsValid(pCBus)){
		TRACE("INVALIDATE THREAD:%lx\n",pCBus);
		return 0;
	}
	LOGST * ptLog=NULL;
	try{
		while(1){
			pCBus->m_iStatus=THREAD_STATUS_WAIT;
			WaitForMultipleObjects(2,&pCBus->m_hMutex,TRUE,INFINITE);
			if(pCBus->m_bExit){
				ReleaseMutex(pCBus->m_hMutex);
				return 0;
			}
			if(!pCBus->IsValid(pCBus)){
				TRACE("INVALIDATE THREAD:%lx\n",pCBus);
				return 0;
			}
			ptLog=pCBus->m_ListLog[0];
			pCBus->m_ListLog.RemoveAt(0);
			ReleaseMutex(pCBus->m_hMutex);
			pCBus->m_iStatus=THREAD_STATUS_WORK;
			pCBus->m_iGetOffNum++;
			CFile cf;
			if(ptLog->icommand==COPYLOGILE){
				if(!ptLog->m_uvFile.IsEmpty()){
					if(ptLog->uvdescripe.IsEmpty()){
						DeleteFile(ptLog->m_uvFile);
						Sleep(10);
					}
					else if(!MoveFile(ptLog->m_uvFile,ptLog->uvdescripe)){
						DeleteFile(ptLog->m_uvFile);
						Sleep(10);
					}
				}
				else {
					if(ptLog->uvdescripe.IsEmpty()){
						DeleteFile(pCBus->m_szLogFile);
						Sleep(10);
					}
					else if(!MoveFile(pCBus->m_szLogFile,ptLog->uvdescripe)){
						DeleteFile(pCBus->m_szLogFile);
						Sleep(10);
					}
				}
			}
			else {
				char * lpFile;
				if(!ptLog->m_uvFile.IsEmpty())
					lpFile=(LPSTR)ptLog->m_uvFile;
				else
					lpFile=pCBus->m_szLogFile;
				BOOL bret=FALSE;
				if(lpFile){
					bret=cf.Open(lpFile,CFile::modeReadWrite|CFile::typeBinary);
					if(!bret)bret=cf.Open(lpFile,CFile::modeCreate|CFile::modeReadWrite|CFile::typeBinary);
				}
				if(bret){
					CString cs;