devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++创建线程实现自动保存队列中的数据_c++保存线程队列然后同时启动

作者：Gausst松鼠会 | 2024-06-12 06:45:08

赞

踩

c++保存线程队列然后同时启动

多线程

互斥量mutex

CreateMutex()函数可用来创建一个有名或无名的互斥量对象

互斥量：

 采用互斥对象机制。互斥锁，像一个物件，这个物件只能同时被一个线程持有。 只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。

互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享。

  1. WINBASEAPI
  2. __out_opt
  3. HANDLE
  4. WINAPI
  5. CreateMutexA(
  6.     __in_opt LPSECURITY_ATTRIBUTES lpMutexAttributes,
  7.     __in     BOOL bInitialOwner,
  8.     __in_opt LPCSTR lpName
  9.     );
  10. WINBASEAPI
  11. __out_opt
  12. HANDLE
  13. WINAPI
  14. CreateMutexW(
  15.     __in_opt LPSECURITY_ATTRIBUTES lpMutexAttributes,
  16.     __in     BOOL bInitialOwner,
  17.     __in_opt LPCWSTR lpName
  18.     );
  19. #ifdef UNICODE
  20. #define CreateMutex  CreateMutexW
  21. #else
  22. #define CreateMutex  CreateMutexA
  23. #endif // !UNICODE

参数说明：

lpMutexAttributes：指向安全属性的指针

bInitialOwner：初始化互斥对象的所有者

 lpName：指向互斥对象名的指针

创建一个互斥量：

  1.  HANDLE m_hMutex = CreateMutex(NULL           /*默认安全属性*/
  2.                         , false               /*创建线程不拥有该信号量*/
  3.                         , NULL                /*锁名称*/
  4.                         );

事件event

CreateEvent是一个windows api函数。它用来创建或打开一个命名的或无名的事件对象

  1. HANDLECreateEvent(
  2. LPSECURITY_ATTRIBUTES lpEventAttributes,// 安全属性
  3. BOOL bManualReset,// 复位方式，手动或自动
  4. BOOL bInitialState,// 初始状态
  5. LPCTSTR lpName // 对象名称
  6. );

bManualReset：

TRUE:必须用ResetEvent函数来手工将事件的状态复原到无信号状态;FALSE，当一个等待线程被释放以后，系统将会自动将事件状态复原为无信号状态

bInitialState：true，初始状态为有信号。

事件(Event)是WIN32提供的最灵活的线程间同步方式，事件可以处于激发状态(signaled or true)或未激发状态(unsignal or false)。

实例：创建线程自动保存队列信号

调用demo

 

源代码

**.h

  1. #pragma once
  2. #include <vector>
  3. #include <queue>
  4. using namespace std;
  5. class CMySaveData
  6. {
  7. public:
  8. 	CMySaveData(void);
  9. 	~CMySaveData(void);
  10. 	CMySaveData(const CMySaveData& copy);
  11. 	CMySaveData& operator = (const CMySaveData& assign);
  12. 	//光程电机位置
  13. 	int m_opPos;
  14. 	//屈光电机位置
  15. 	int m_refPos;
  16. 	//Z电机位置
  17. 	int m_motoZPos;
  18. 	//图片编号
  19. 	int m_imgNum;
  20. };
  21. enum ENU_DATA_TYPE
  22. {
  23. 	ISO,
  24. 	OCT	
  25. };
  26.  
  27. class DataSaveRequest
  28. {
  29. public:
  30. 	DataSaveRequest(ENU_DATA_TYPE enuDataType, CMySaveData mydata);
  31. 	DataSaveRequest();
  32. 	~DataSaveRequest();
  33.  
  34. 	CMySaveData m_data;
  35. 	ENU_DATA_TYPE m_enuDataType;
  36. };
  37.  
  38. class SaveDataInfo
  39. {
  40. public:
  41. 	SaveDataInfo(void);
  42. 	~SaveDataInfo(void);
  43. private:
  44. 	HANDLE m_Mutex;
  45. 	HANDLE m_ExitEvent;
  46. 	bool m_bIsThreadOn;
  47. 	int m_iSaveCount;	
  48. 	std::queue<DataSaveRequest> m_queueDataInfo;
  49. 	FILE * m_pfile;
  50. private:
  51. 	static void SavingThread(void* param);
  52. 	void Save(const DataSaveRequest& dsr);
  53. 	DataSaveRequest PopDataSaveRequest();
  54. 	void SaveMyData(DataSaveRequest dsr);
  55. 	void PushBackDataSaveRequest(const DataSaveRequest& dsr);
  56. public:	
  57. 	void Stop();
  58. 	void SetMyData(CMySaveData myData);	
  59. 	void Begin(const CString &strFileDirPath,ENU_DATA_TYPE type);
  60. };
  61.

**.cpp

  1. #include "StdAfx.h"
  2. #include "SaveDataInfo.h"
  3. #include <WinBase.h>
  4. DataSaveRequest::DataSaveRequest(ENU_DATA_TYPE enuDataType, CMySaveData mydata)
  5. 	:m_enuDataType(enuDataType),m_data(mydata)
  6. {
  7.  
  8. }
  9. DataSaveRequest::DataSaveRequest()
  10. {
  11. 	m_enuDataType=ISO;
  12. }
  13. DataSaveRequest::~DataSaveRequest()
  14. {
  15. }
  16. CMySaveData::CMySaveData(void)
  17. {
  18. 	
  19. }
  20. CMySaveData::~CMySaveData(void)
  21. {
  22. 	
  23. }
  24. CMySaveData::CMySaveData(const CMySaveData& copy)
  25. {
  26. 	//CLog::GetInstance()->WriteLog(_T("MyLine::MyLine(const MyLine& copy)"));
  27. 	m_refPos=copy.m_refPos;
  28. 	m_motoZPos=copy.m_motoZPos;
  29. 	m_opPos=copy.m_opPos;
  30. 	m_imgNum=copy.m_imgNum;
  31.  
  32. }
  33. CMySaveData& CMySaveData::operator = (const CMySaveData& assign)
  34. {
  35. 	if(this != &assign){
  36. 		m_refPos=assign.m_refPos;
  37. 		m_opPos=assign.m_opPos;
  38. 		m_motoZPos=assign.m_motoZPos;
  39. 		m_imgNum=assign.m_imgNum;
  40.  
  41. 	
  42. 	}
  43.  
  44.  
  45. 	return *this;
  46.  
  47. }
  48.  
  49. SaveDataInfo::SaveDataInfo(void)
  50. {
  51. 	m_bIsThreadOn = false;
  52. 	m_Mutex = CreateMutex(NULL, FALSE, NULL);
  53. 	//ResetEvent手动将事件的状态复原到无信号状态，初始状态没没有信号
  54. 	m_ExitEvent = CreateEvent(NULL, TRUE, FALSE, _T("m_ExitEvent"));
  55. }
  56.  
  57.  
  58. SaveDataInfo::~SaveDataInfo(void)
  59. {
  60. 	
  61. 	fclose (m_pfile);
  62. 	CloseHandle(m_Mutex);
  63. 	CloseHandle(m_ExitEvent);
  64. }
  65.  
  66. void SaveDataInfo::Begin(const CString &strFileDirPath,ENU_DATA_TYPE type)
  67. {
  68. 	
  69. 	if (m_bIsThreadOn)
  70. 	{
  71. 		//如果线程已经创建，直接返回
  72. 		return;
  73. 	}
  74.  
  75. 	BOOL bIsDirNormal = TRUE;
  76. 	if (!PathIsDirectory(strFileDirPath))
  77. 	{
  78. 		//如果路径不存在创建路径
  79. 		bIsDirNormal = CreateDirectory(strFileDirPath, NULL);
  80. 	}
  81.  
  82. 	if(!bIsDirNormal)
  83. 	{
  84. 		//创建路径失败，直接返回
  85. 		return;
  86. 	}
  87.  
  88. 	m_iSaveCount = 0;
  89. 	
  90. 	m_bIsThreadOn = true;
  91. 	CString filePath;
  92. 	if (ISO == type)
  93. 	{
  94. 		filePath.AppendFormat(_T("%s/ISO_PosInfo.txt"), strFileDirPath);
  95. 	}
  96. 	else if (OCT == type)
  97. 	{
  98. 		filePath.AppendFormat(_T("%s/ISO_PosInfo.txt"), strFileDirPath);	
  99. 	}  
  100. 	
  101. 	const size_t strSize=(filePath.GetLength()+1)*2;
  102. 	char* pstr=new char[strSize];
  103. 	size_t sz=0;
  104. 	wcstombs_s(&sz,pstr,strSize,filePath,_TRUNCATE);
  105.  
  106. 	m_pfile = fopen((const char*)pstr,"w+");
  107. 	//启动保存数据线程
  108. 	_beginthread(SavingThread, 0, this);
  109. }
  110.  
  111. void SaveDataInfo::SavingThread(void* param)
  112. {
  113. 	SaveDataInfo* pDataSaver = (SaveDataInfo*)param;
  114. 	//如果保存线程没有退出，或者保存的数据不为空
  115. 	while (pDataSaver->m_bIsThreadOn || (!pDataSaver->m_queueDataInfo.empty()))
  116. 	{
  117. 		if (pDataSaver->m_queueDataInfo.size() <= 0)
  118. 		{
  119. 			Sleep(50);
  120. 			continue;
  121. 		}
  122. 		DataSaveRequest dsr = pDataSaver->PopDataSaveRequest();
  123. 		pDataSaver->Save(dsr);
  124. 		
  125. 	}
  126. 	//设置m_ExitEvent为有信号状态，激活m_ExitEvent
  127. 	SetEvent(pDataSaver->m_ExitEvent);
  128.  
  129. }
  130. void SaveDataInfo::Stop()
  131. {
  132. 	//设置m_ExitEvent为无信号状态
  133. 	ResetEvent(m_ExitEvent);
  134. 	m_bIsThreadOn = false;
  135. 	//等待m_ExitEvent事件被激活，m_ExitEvent有信号
  136. 	WaitForSingleObject(m_ExitEvent, INFINITE);
  137. }
  138. //取出一个保存请求
  139. DataSaveRequest SaveDataInfo::PopDataSaveRequest()
  140. {
  141. 	DataSaveRequest dsr;
  142. 	WaitForSingleObject(m_Mutex, INFINITE);
  143. 	dsr = m_queueDataInfo.front();
  144. 	m_queueDataInfo.pop();
  145. 	ReleaseMutex(m_Mutex);
  146. 	return dsr;
  147. }
  148. void SaveDataInfo::Save(const DataSaveRequest& dsr)
  149. {		
  150. 	
  151. 	SaveMyData(dsr);
  152.  
  153. }
  154.  
  155. void SaveDataInfo::PushBackDataSaveRequest(const DataSaveRequest& dsr)
  156. {
  157. 	WaitForSingleObject(m_Mutex, INFINITE);
  158. 	m_queueDataInfo.push(dsr);
  159. 	ReleaseMutex(m_Mutex);
  160. }
  161.  
  162. void SaveDataInfo::SetMyData(CMySaveData myData)
  163. {
  164. 	DataSaveRequest dsr(ENU_DATA_TYPE::ISO, myData);	
  165. 	PushBackDataSaveRequest(dsr);
  166. }
  167.  
  168. void SaveDataInfo::SaveMyData(DataSaveRequest dsr)
  169. {
  170. 	
  171. 	CMySaveData tmdata=dsr.m_data;
  172. 	fprintf(m_pfile,"图片编号:%d,\tZ电机位置:%d,\t屈光位置：%d,\t光程位置:%d\n",tmdata.m_imgNum,tmdata.m_motoZPos,tmdata.m_refPos,tmdata.m_opPos);
  173. }

automotodatasaver.h

  1. /************************************************************************/
  2. /* 眼动追踪数据保存（保存追踪过程中的相关数据）                         */
  3. /************************************************************************/
  4. #pragma once
  5. #include <queue>
  6. //#include "ImgPro.h"
  7. //#include "utility.h"
  8. #include "..\..\..\ImgPro.h"
  9. #include "..\..\utility.h"
  10. class CLog;
  11.  
  12. namespace MoptimOct{
  13.  
  14. 	class AutoMotoDataSaver
  15. 	{
  16. 	private:
  17. 		enum ENU_DATA_TYPE
  18. 		{
  19. 			RegisResult,
  20. 			BaseLso,
  21. 			RegisLso,
  22. 			OriginalOct,
  23. 			Reversed
  24. 		};
  25.  
  26. 		class DataSaveRequest
  27. 		{
  28. 		public:
  29. 			DataSaveRequest(ENU_DATA_TYPE enuDataType, const PUSHORT pData, int iImageWidth = 0, int iImageHeight = 0);
  30. 			DataSaveRequest();
  31. 			~DataSaveRequest();
  32.  
  33. 			void Release();
  34.  
  35. 			BYTE* m_pData;
  36. 			int m_iImageWidth;
  37. 			int m_iImageHeight;
  38. 			size_t m_iDataSize;
  39. 			int m_iId;	
  40. 			int m_iNum;
  41. 			ENU_DATA_TYPE m_enuDataType;
  42. 		};
  43.  
  44. 		CString m_strFileDirPath;
  45.  
  46. 		std::queue<DataSaveRequest> m_queueDataInfo;
  47.  
  48. 		HANDLE m_Mutex;
  49.  
  50. 		bool m_bIsThreadOn;
  51.  
  52. 		int m_iSaveCount;
  53.  
  54. 		HANDLE m_ExitEvent;
  55.  
  56. 		CLog *m_pLog;
  57.  
  58. 	public:
  59. 		AutoMotoDataSaver();
  60. 		virtual ~AutoMotoDataSaver();
  61.  
  62. 		void Begin(const CString &strFilePath);
  63. 		void Stop();
  64.  
  65. 		void SetLsoRegisResultData(const ST_LSO_REGIS_RESULT& stRegisResultData, int iId = 0);
  66. 		void SetBaseLsoData(const PUSHORT pHDLSO, int width=VEDIOWIDTH, int height=VEDIOHEIGHT, int iId = 0,int iNum=0);
  67. 		void SetRegisLsoData(const PUSHORT pSmallLSO, int width=SMALL_LSO_WIDTH, int height=SMALL_LSO_HEIGHT, int iId = 0);
  68. 		void SetOriginalOctData(const PUSHORT pOctOriData, int width, int height, int iId = 0);
  69.  
  70. 	private:
  71. 		void PushBackDataSaveRequest(const DataSaveRequest& dsr);
  72. 		DataSaveRequest PopDataSaveRequest();
  73. 		void Save(const DataSaveRequest& dsr);
  74. 		void SaveBitmapToFile(DataSaveRequest dsr,CString m_szFileName/*PUSHORT pBytes,int num*/);
  75. 		static void SavingThread(void* param);
  76. 	};
  77. }
  78.

automotodatasaver.cpp

  1. #include "stdafx.h"
  2. #include "AutoMotoDataSaver.h"
  3. #include <process.h>
  4. #include <iostream>
  5. #include <fstream>
  6. #include "../../Log.h"
  7. #include "ProcessFile.h"
  8.  
  9. namespace MoptimOct{
  10.  
  11. 	AutoMotoDataSaver::DataSaveRequest::DataSaveRequest(ENU_DATA_TYPE enuDataType, 
  12. 		const PUSHORT pData, int iImageWidth /*= 0*/, int iImageHeight /*= 0*/)
  13. 		:m_enuDataType(enuDataType), m_pData(NULL), m_iImageWidth(iImageWidth), m_iImageHeight(iImageHeight),
  14. 		m_iId(0),m_iNum(0)
  15. 	{
  16. 		BYTE *pdata = new BYTE[VEDIOWIDTH * VEDIOHEIGHT *3];
  17. 		int k = 0;
  18. 		for(int i = 0;i<VEDIOWIDTH * VEDIOHEIGHT;i++)
  19. 		{
  20. 			pdata[k] =(BYTE)pData[i];
  21. 			pdata[k+1] =(BYTE) pData[i];
  22. 			pdata[k+2] = (BYTE)pData[i];
  23. 			k+=3;
  24. 		}
  25. 			
  26. 		m_pData = pdata;
  27. 	}
  28.  
  29. 	AutoMotoDataSaver::DataSaveRequest::DataSaveRequest()
  30. 		:m_enuDataType(RegisResult), m_pData(NULL), m_iImageWidth(0), m_iImageHeight(0),
  31. 		m_iId(0)
  32. 	{
  33. 	}
  34.  
  35. 	AutoMotoDataSaver::DataSaveRequest::~DataSaveRequest()
  36. 	{
  37. 	}
  38.  
  39. 	void AutoMotoDataSaver::DataSaveRequest::Release()
  40. 	{
  41. 		if(NULL == m_pData)
  42. 		{
  43. 			return;
  44. 		}
  45.  
  46. 		BYTE *pBytes = (BYTE*)m_pData;
  47. 		delete[] pBytes;		
  48.  
  49. 		m_pData = NULL;
  50. 	}
  51.  
  52. 	AutoMotoDataSaver::AutoMotoDataSaver():m_bIsThreadOn(false),m_iSaveCount(0),m_pLog(0)
  53. 	{
  54. 		m_pLog = CLog::GetInstance();
  55.  
  56. 		m_Mutex = CreateMutex(NULL, FALSE, NULL);
  57. 		m_ExitEvent = CreateEvent(NULL, TRUE, FALSE, _T("m_ExitEvent"));
  58. 	}
  59.  
  60. 	AutoMotoDataSaver::~AutoMotoDataSaver()
  61. 	{
  62. 		CloseHandle(m_Mutex);
  63. 		CloseHandle(m_ExitEvent);
  64. 	}
  65.  
  66. 	void AutoMotoDataSaver::Begin(const CString &strFileDirPath)
  67. 	{
  68. 		if (m_bIsThreadOn)
  69. 		{
  70. 			CLog::GetInstance()->WriteLog(_T("AutoMotoDataSaver::Begin,if (m_bIsThreadOn)"));
  71. 			return;
  72. 		}
  73.  
  74. 		BOOL bIsDirNormal = TRUE;
  75. 		if (!PathIsDirectory(strFileDirPath))
  76. 		{
  77. 			CLog::GetInstance()->WriteLog(_T("AutoMotoDataSaver::Begin,if (!PathIsDirectory(strFileDirPath))"));
  78.  
  79. 			bIsDirNormal = CreateDirectory(strFileDirPath, NULL);
  80. 		}
  81.  
  82. 		if(!bIsDirNormal)
  83. 		{
  84. 			return;
  85. 		}
  86.  
  87. 		m_iSaveCount = 0;
  88. 		m_strFileDirPath = strFileDirPath;
  89. 		m_bIsThreadOn = true;
  90. 		CLog::GetInstance()->WriteLog(_T("AutoMotoDataSaver::Begin,_beginthread(SavingThread, 0, this);"));
  91.  
  92. 		_beginthread(SavingThread, 0, this);
  93. 	}
  94.  
  95. 	void AutoMotoDataSaver::Stop()
  96. 	{
  97. 		ResetEvent(m_ExitEvent);
  98. 		m_bIsThreadOn = false;
  99. 		WaitForSingleObject(m_ExitEvent, INFINITE);
  100. 	}
  101.  
  102. 	void AutoMotoDataSaver::SetLsoRegisResultData(const ST_LSO_REGIS_RESULT& stRegisResultData, int iId)
  103. 	{
  104. 		/*if (!m_pLog->CheckSaveDataMask(LOG_SAVE_TRACING_REGISRESULT))
  105. 		{
  106. 			return;
  107. 		}
  108.  
  109. 		DataSaveRequest dsr(AutoMotoDataSaver::RegisResult, (void*)&stRegisResultData);
  110. 		dsr.m_iId = iId;
  111. 		PushBackDataSaveRequest(dsr);*/
  112. 	}
  113.  
  114. 	void AutoMotoDataSaver::SetBaseLsoData(const PUSHORT pHDLSO, int width, int height, int iId,int iNum)
  115. 	{
  116. 		/*if (!m_pLog->CheckSaveDataMask(LOG_SAVE_TRACING_HDLSO))
  117. 		{
  118. 			return;
  119. 		}*/
  120.  
  121. 		DataSaveRequest dsr(AutoMotoDataSaver::BaseLso, pHDLSO, width, height);
  122. 		dsr.m_iId = iId;
  123. 		dsr.m_iNum=iNum;
  124. 		PushBackDataSaveRequest(dsr);
  125.  
  126. 	}
  127.  
  128. 	void AutoMotoDataSaver::SetRegisLsoData(const PUSHORT pSmallLSO, int width/*=SMALL_LSO_WIDTH*/, int height/*=SMALL_LSO_HEIGHT*/, int iId)
  129. 	{
  130. 		/*if (!m_pLog->CheckSaveDataMask(LOG_SAVE_TRACING_SMALLHDLSO))
  131. 		{
  132. 		return;
  133. 		}*/
  134.  
  135. 		/*DataSaveRequest dsr(AutoMotoDataSaver::RegisLso, (void*)pSmallLSO, width, height);
  136. 		dsr.m_iId = iId;
  137. 		PushBackDataSaveRequest(dsr);*/
  138. 	}
  139.  
  140. 	void AutoMotoDataSaver::SetOriginalOctData(const PUSHORT pOctOriData, int width, int height, int iId)
  141. 	{
  142. 		/*if (!m_pLog->CheckSaveDataMask(LOG_SAVE_TRACING_ORIGINALOCT))
  143. 		{
  144. 		return;
  145. 		}*/
  146.  
  147. 		/*DataSaveRequest dsr(AutoMotoDataSaver::OriginalOct, (void*)pOctOriData, width, height);
  148. 		dsr.m_iId = iId;
  149. 		PushBackDataSaveRequest(dsr);*/
  150. 	}
  151.  
  152. 	void AutoMotoDataSaver::PushBackDataSaveRequest(const DataSaveRequest& dsr)
  153. 	{
  154. 		WaitForSingleObject(m_Mutex, INFINITE);
  155. 		m_queueDataInfo.push(dsr);
  156. 		ReleaseMutex(m_Mutex);
  157. 	}
  158.  
  159. 	AutoMotoDataSaver::DataSaveRequest AutoMotoDataSaver::PopDataSaveRequest()
  160. 	{
  161. 		DataSaveRequest dsr;
  162. 		WaitForSingleObject(m_Mutex, INFINITE);
  163. 		dsr = m_queueDataInfo.front();
  164. 		m_queueDataInfo.pop();
  165. 		ReleaseMutex(m_Mutex);
  166.  
  167. 		return dsr;
  168. 	}
  169.  
  170. 	void AutoMotoDataSaver::Save(const DataSaveRequest& dsr)
  171. 	{		
  172. 		CString filePath;
  173. 		if (RegisResult == dsr.m_enuDataType)
  174. 		{
  175. 			filePath.AppendFormat(_T("%s/RegisResult.txt"), m_strFileDirPath);
  176. 			ST_LSO_REGIS_RESULT* pRegisResult = (ST_LSO_REGIS_RESULT*)dsr.m_pData;
  177.  
  178. 			CString strRegisResult;
  179. 			strRegisResult.AppendFormat(_T("ID=%d state=%d xOffset=%lf yOffset=%lf\r\n"), 
  180. 				dsr.m_iId, (int)(pRegisResult->state), pRegisResult->xOffset, pRegisResult->yOffset);
  181. #ifdef UNICODE
  182. 			std::wofstream ofs(filePath, std::ios::out | std::ios::app);
  183. 			ofs << strRegisResult.GetBuffer();
  184. #else
  185. 			std::ofstream ofs(filePath, std::ios::out);
  186. 			ofs << strRegisResult;
  187. #endif
  188. 		}
  189. 		else
  190. 		{
  191. 			if (BaseLso == dsr.m_enuDataType)
  192. 			{
  193. 				filePath.AppendFormat(_T("%s%d.BMP"), m_strFileDirPath, dsr.m_iNum/*,dsr.m_iId*/);
  194. 				CLog::GetInstance()->WriteLog(_T("保存虹膜图，SaveBitmapToFile,dsr.m_iNum: %d,dsr.m_iId: %d"),dsr.m_iNum,dsr.m_iId);
  195. 				//CLog::GetInstance()->WriteLog(filePath);
  196. 				SaveBitmapToFile(dsr,filePath);
  197. 			}
  198. 			else if(RegisLso == dsr.m_enuDataType)
  199. 			{
  200. 				filePath.AppendFormat(_T("%s/RegisLso_%d.bin"), m_strFileDirPath,  /*dsr.m_iNum,*/dsr.m_iId);
  201. 			}
  202. 			else if(OriginalOct == dsr.m_enuDataType)
  203. 			{
  204. 				filePath.AppendFormat(_T("%s/OriginalOct_%d.bin"), m_strFileDirPath/*,  dsr.m_iNum*/,dsr.m_iId);
  205. 			}
  206. 			
  207. 		}  
  208.  
  209. 	}
  210.  
  211. 	void AutoMotoDataSaver::SavingThread(void* param)
  212. 	{
  213. 		AutoMotoDataSaver* pDataSaver = (AutoMotoDataSaver*)param;
  214. 		while (pDataSaver->m_bIsThreadOn || (!pDataSaver->m_queueDataInfo.empty()))
  215. 		{
  216. 			if (pDataSaver->m_queueDataInfo.size() <= 0)
  217. 			{
  218. 				Sleep(50);
  219. 				continue;
  220. 			}
  221. 			CLog::GetInstance()->WriteLog(_T("pDataSaver->m_queueDataInfo.size()：%d"),pDataSaver->m_queueDataInfo.size());
  222. 			DataSaveRequest dsr = pDataSaver->PopDataSaveRequest();
  223. 			pDataSaver->Save(dsr);
  224. 			dsr.Release();
  225. 		}
  226.  
  227. 		SetEvent(pDataSaver->m_ExitEvent);
  228.  
  229. 	}
  230.  
  231. 	void AutoMotoDataSaver::SaveBitmapToFile(DataSaveRequest dsr,CString m_szFileName)
  232. 	{
  233. 		/*PUSHORT pBytes,int num*/
  234. 		//灰度图转换为彩色图
  235. 		if(dsr.m_pData != NULL)
  236. 		{
  237. 			CLog::GetInstance()->WriteLog(_T("保存虹膜图，ProcessFile::SaveBitmapToFile"));
  238. 			ProcessFile::SaveBitmapToFile(dsr.m_pData, 24,m_szFileName,VEDIOWIDTH, VEDIOHEIGHT);
  239. 			
  240. 		}else{
  241. 			CLog::GetInstance()->WriteLog(_T("dsr.m_pData == NULL"));
  242. 		}
  243.  
  244. 		
  245. 	}
  246.  
  247. }

总结

可以继续把SaveDataInfo和AutoMotoDataSaver采用模板类的方式实现，代码复用性会更高。查阅一下设计模式和模板类相关资料

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/706836
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号