创建一个C++线程类：C++中独立于平台的线程
简介
最近，有人问到，是否有一种简单的方法创建一个C++类，以便有助于编写面向对象的线程，而且这个线程类还要有以下属性：
支持事件驱动及基于间隔的异步线程。
支持生成同种及特定的线程。
提供一个FCFS（先来先服务）的堆栈队列用于发送及处理多任务。
可移植。
易于实现。
为支持新类CThread，还需要编写出其他相关的类，这些类包括：CMutexClass、CEventClass、CTask，CMutexClass及CEventClass提供资源管理，而CTask是一个用于派生的基类，其支持同种异步线程。
什么是线程？
每个进程至少有一个控制线程，且每个进程在同一时间至少能执行一项任务，有多种控制线程的进程称为多线程进程，一个多线程进程可在自身环境内异步运行多个任务。
资源管理——线程同步
因为进程内的线程分享相同的资源，所以需要在系统级别上设置控制机制来保证数据的完整性。当一个线程修改了某个变量，而另一个线程试图读取它时，或者两个线程同时修改同一变量，就会影响到数据的完整性，为防止这个问题，操作系统提供了一种相互排斥对象，简写为mutex。在多线程程序中，mutex是通过编程来实现的，可防止多个线程在同一时间访问同一资源。当一个线程需要访问某一资源时，它必须先请求一个mutex，一旦线程得到一个mutex，其他想获取同一mutex的线程被阻塞，并处于低CPU占用的等待状态；一旦这个线程完成了数据访问，它会释放对应的mutex，这就允许其他线程获取以访问相关的数据。
如果mutex实现得不好，将会导致资源饥饿，也就是常说的死锁。资源饥饿发生在当一个或多个线程竞争同一资源时，如果一个线程请求一个mutex两次，也可能会发生死锁。
<!-- @page { margin: 2cm } TD P { margin-bottom: 0cm } P { margin-bottom: 0.21cm } -->
-
线程A
线程B
请求mutex1修改数据项1
请求mutex2修改数据项2
想要mutex2查看数据项2
想要mutex1查看数据项1
在上表中，就会发生死锁，因为线程A想要获取mutex2时被阻塞，而它正被线程B所持有；线程B想要获取mutex1时被阻塞，而它正被线程A所持有。
与mutex类似，Unix中的条件变量，也是一种同步机制。条件变量允许线程会合，可让一个线程在有变化时通知另一个线程，这在Windows中，被称为events。
操作系统的调用
下表列出的函数均可用于在CMutexClass、CEventClass、CTask及CThread类中实现线程。
<!-- @page { margin: 2cm } P { margin-bottom: 0.21cm } -->
| 函数 | 操作系统 | 描述 | 使用的类 |
| CreateThread | Windows | 创建一个Windows线程 | CThread |
| pthread_create | UNIX - POSIX THREADS | 创建一个UNIX线程 | CThread |
| pthread_join | UNIX - POSIX THREADS | 等待一个UNIX线程结束 | CThread |
| pthread_attr_init | UNIX - POSIX THREADS | 将某一线程属性结构设为默认 | CThread |
| pthread_attr_setstacksize | UNIX - POSIX THREADS | 设置线程属性结构的堆栈大小 | CThread |
| WaitForSingleObject | Windows | 等待一个对象有信号 | CThread, CMutexClass, CEventClass |
| CreateMutex | Windows | 创建一个命名或未命名的mutex | CMutexClass |
| CloseHandle | Windows | 关闭某一Windows句柄以释放资源 | CMutexClass, CEventClass, CThread |
| ReleaseMutex | Windows | 释放某一之前获取，并由WaitForSingleObject锁定的 mutex | CMutexClass, CEventClass |
| pthread_mutexattr_init | UNIX - POSIX THREADS | 初始化某一mutex属性结构 | CMutexClass, CEventClass |
| pthread_mutex_init | UNIX - POSIX THREADS | 用给定的属性结构初始化某一mutex | CMutexClass, CEventClass |
| pthread_mutex_lock | UNIX - POSIX THREADS | 锁定某一mutex | CMutexClass, CEventClass |
| pthread_mutex_unlock | UNIX - POSIX THREADS | 解锁某一之前由pthread_mutex_lock锁定的mutex | CMutexClass, CEventClass |
| pthread_mutex_destroy | UNIX - POSIX THREADS | 释放分配给mutex的资源 | CMutexClass, CEventClass |
| CreateEvent | Windows | 创建一个Windows事件对象 | CEventClass |
| SetEvent | Windows | 设置某一Windows事件对象为有信号状态 | CEventClass |
| pthread_cond_signal | UNIX - POSIX THREADS | 解除由pthread_cond_wait阻塞的某一线程 | CEventClass |
| pthread_cond_wait | UNIX - POSIX THREADS | 基于条件变量进行阻塞 | CEventClass |
| pthread_cond_init | UNIX - POSIX THREADS | 初始化一个条件变量 | CEventClass |
类CMutexClass
类CMutexClass封装了系统级的mutex函数及一个mutex同步对象，且提供了两个成员函数：Lock及Unlock。Lock成员函数锁定一个mutex并把它赋给一个调用线程，mutex一直保持锁定状态直到调用线程使用Unlock成员函数释放它。任何调用Lock成员函数想获取锁定mutex的线程将被阻塞，并置于低CPU占用的等待状态，直到有线程释放了mutex。
CMutexClass::CMutexClass(void):m_bCreated(TRUE)
{
#ifdef WINDOWS
m_mutex = CreateMutex(NULL,FALSE,NULL);
if( !m_mutex ) m_bCreated = FALSE;
#else
pthread_mutexattr_t mattr;
pthread_mutexattr_init( &mattr );
pthread_mutex_init(&m_mutex,&mattr);
#endif
memset(&m_owner,0,sizeof(ThreadId_t));
}
CMutexClass::~CMutexClass(void)
{
#ifdef WINDOWS
WaitForSingleObject(m_mutex,INFINITE);
CloseHandle(m_mutex);
#else
pthread_mutex_lock(&m_mutex);
pthread_mutex_unlock(&m_mutex);
pthread_mutex_destroy(&m_mutex);
#endif
}
/**
*
* Lock
* 同一线程只能锁定同一mutex一次
*
**/
void
CMutexClass::Lock()
{
ThreadId_t id = CThread::ThreadId();
try {
if(CThread::ThreadIdsEqual(&m_owner,&id) )
// mutex已被这个线程锁定
throw "/n/t the same thread can not acquire a mutex twice!/n";
#ifdef WINDOWS
WaitForSingleObject(m_mutex,INFINITE);
#else
pthread_mutex_lock(&m_mutex);
#endif
m_owner = CThread::ThreadId();
}
catch( char *psz )
{
#ifdef WINDOWS
MessageBoxA(NULL,&psz[2],"Fatal exception CMutexClass::Lock",
MB_ICONHAND);
exit(-1);
#else
cerr << "Fatal exception CMutexClass::Lock : " << psz;
#endif
}
}
/**
*
* Unlock
* 只有获取该mutex的线程能释放它
*
**/
void
CMutexClass::Unlock()
{
ThreadId_t id = CThread::ThreadId();
try
{
if( ! CThread::ThreadIdsEqual(&id,&m_owner) )
throw "/n/t only the thread that acquires a mutex can
release it!";
memset(&m_owner,0,sizeof(ThreadId_t));
#ifdef WINDOWS
ReleaseMutex(m_mutex);
#else
pthread_mutex_unlock(&m_mutex);
#endif
}
catch ( char *psz)
{
#ifdef WINDOWS
MessageBoxA(NULL,&psz[2],"Fatal exception CMutexClass::Unlock",
MB_ICONHAND);
exit(-1);
#else
cerr << "Fatal exception CMutexClass::Unlock : " << psz;
#endif
}
}
<!-- @page { margin: 2cm } P { margin-bottom: 0.21cm } -->
-
函数
描述
void CMutexClass()
构造函数
void Lock()
锁定mutex对象或当它阻塞时等待
void Unlock()
解锁之前阻塞的mutex
int g_iStorage = 0;
CMutexClass MyMutex;
void StoreValue( int *pInt )
{
MyMutex.Lock(); //它可是“掌门人”喔，一个只允许一个线程。
g_iStorage = *pInt; //受保护的数据，关键代码段。
MyMutex.Unlock(); //解锁，允许其他线程访问g_iStorage
}
类CEventClass
类CEventClass封装了Windows事件函数、Windows事件对象、Unix条件变量函数、Unix条件变量。集成到CEventClass类中的函数分别为Windows下的SetEvent及CreateEvent，Unix下的htread_cond_init、pthread_cond_destroy、pthread_cond_signal、pthread_cond_wait。在Unix下，为了简单起见，事件同步对象被称为条件变量，在此我们把条件变量及事件对象均称为事件对象。
#include "Thread.h"
#include <iostream>
using namespace std;
CEventClass::CEventClass(void):m_bCreated(TRUE)
{
memset(&m_owner,0,sizeof(ThreadId_t));
#ifdef WINDOWS
m_event = CreateEvent(NULL,FALSE,FALSE,NULL);
if( !m_event )
{
m_bCreated = FALSE;
}
#else
pthread_mutexattr_t mattr;
pthread_mutexattr_init(&mattr);
pthread_mutex_init(&m_lock,&mattr);
pthread_cond_init(&m_ready,NULL);
#endif
}
CEventClass::~CEventClass(void)
{
#ifdef WINDOWS
CloseHandle(m_event);
#else
pthread_cond_destroy(&m_ready);
pthread_mutex_destroy(&m_lock);
#endif
}
/**
*
* Set
* 设置某一事件为有信号状态
*
**/
void
CEventClass::Set()
{
#ifdef WINDOWS
SetEvent(m_event);
#else
pthread_cond_signal(&m_ready);
#endif
}
/**
*
* Wait
* 等待一个事件对象为有信号状态，必须在同一线程中与Reset调用成对使用。
*
**/
BOOL
CEventClass::Wait()
{
try
{
ThreadId_t id = CThread::ThreadId();
if( CThread::ThreadIdsEqual(&id,&m_owner) )
{
throw "/n/t invalid Wait call, Wait can not be called more
than once"
"/n/t without a corresponding call to Reset!/n";
}
ThreadId_t zero;
memset(&zero,0,sizeof(ThreadId_t));
if( memcmp(&zero,&m_owner,sizeof(ThreadId_t)) != 0 )
{
throw "/n/t another thread is already waiting on this event!/n";
}
m_owner = CThread::ThreadId();
#ifdef WINDOWS
if( WaitForSingleObject(m_event,INFINITE) != WAIT_OBJECT_0 )
{
return FALSE;
}
#else
pthread_mutex_lock(&m_lock);
pthread_cond_wait(&m_ready,&m_lock);
return TRUE;
#endif
}
catch( char *psz )
{
#ifdef WINDOWS
MessageBoxA(NULL,&psz[2],"Fatal exception CEventClass::Wait",
MB_ICONHAND);
exit(-1);
#else
cerr << "Fatal exception CEventClass::Wait: " << psz;
#endif
}
return TRUE;
}
/**
*
* Reset
* 复位一个事件标志为无信号状态，必须在同一线程中与前面的Wait成对使用。
*
**/
void
CEventClass::Reset()
{
try
{
ThreadId_t id = CThread::ThreadId();
if( !CThread::ThreadIdsEqual(&id,&m_owner) )
{
throw "/n/t unbalanced call to Reset, Reset must be called
from/n"
"/n/t the same Wait-Reset pair!/n";
}
memset(&m_owner,0,sizeof(ThreadId_t));
#ifndef WINDOWS
pthread_mutex_unlock(&m_lock);
#endif
}
catch( char *psz )
{
#ifdef WINDOWS
MessageBoxA(NULL,&psz[2],"Fatal exception CEventClass::Reset",
MB_ICONHAND);
exit(-1);
#else
cerr << "Fatal exception CEventClass::Reset: " << psz;
#endif
}
}
<!-- @page { margin: 2cm } P { margin-bottom: 0.21cm } -->
| 函数 | 描述 |
| void Set() | 设置一个事件状态为有信号，通知阻塞的线程。 |
| BOOL Wait() | 把调用线程置于阻塞状态，直到事件状态为有信号。成功返回TRUE，否则返回FALSE。 |
| void Reset() | 把一个有信号事件重置为无信号状态。 |
接收信号的线程使用事件对象的例子：
CEventClass event;
.
.
//线程代码
.
.
while(bContinueRunning)
{
event.Wait(); // 等待事件发生
// 执行某些任务
.
.
event.Reset(); // 重置事件为无信号状态
}
.
.
向另一线程发信号时使用事件对象的例子：
CEventClass event;
.
.
// 改动了一些数据
.
.
event.Set(); // 通知线程一个事件已发生，设置事件为有信号状态。
.
.
CTask类及非特定的线程
在许多线程编程的示例中，线程处理的数据一般都放在由mutex保护的全局变量中，操纵数据的指令也在集成进线程函数中，我们把这种形式的的线程称为特定异步线程（SAT）；理想上来说，数据及对应的处理数据的功能，都应封装进同一对象，我们把这种形式的线程称为同种异步线程（HAT）。在HAT模式下，线程不是特定的，举例来说，HAT中就没有打印线程及I/O线程，取而代之的是，单一线程能执行这两种任务，因为任务是彻底作为对象来实现的，那就是说，它们包含了数据及必要的功能。CTask类就是一个采用HAT线程模式的基类。
typedef enum {
TaskStatusNotSubmitted,
TaskStatusWaitingOnQueue,
TaskStatusBeingProcessed,
TaskStatusCompleted } TaskStatus_t;
class CTask
{
private:
CMutexClass m_mutex;
TaskStatus_t m_state;
ThreadId_t m_dwThread;
public:
void SetTaskStatus(TaskStatus_t state)
{
m_mutex.Lock();
m_state=state;
m_mutex.Unlock();
}
void SetId(ThreadId_t *pid)
{
memcpy(&m_dwThread,pid,sizeof(ThreadId_t));
}
/**
*
* Wait
* 等待任务完成，或timeoutSeconds秒
*
**/
BOOL Wait(int timeoutSeconds)
{
timeoutSeconds = timeoutSeconds * 1000;
if( Status() != TaskStatusCompleted &&
timeoutSeconds > 0 )
{
Sleep(100);
timeoutSeconds = timeoutSeconds - 100;
}
if( Status() == TaskStatusCompleted ) return TRUE;
return FALSE;
}
/**
*
* 在此返回任务的当前状态
*
**/
TaskStatus_t Status()
{
TaskStatus_t state ;
m_mutex.Lock();
state = m_state;
m_mutex.Unlock();
return state;
}
void Thread(ThreadId_t *pId)
{
memcpy(pId,&m_dwThread,sizeof(ThreadId_t));
}
CTask(){m_state=TaskStatusNotSubmitted;
memset(&m_dwThread,sizeof(ThreadId_t),0); }
~CTask(){}
virtual BOOL Task()=0;
};
<!-- @page { margin: 2cm } P { margin-bottom: 0.21cm } -->
| 函数 | 描述 |
| m_mutex | Mutex类型的同步对象 |
| virtual BOOL Task() | 由一CThread对象调用执行相应任务 |
| TaskStatus_t Status() | 确定任务状态：TaskStatusNotSubmitted、TaskStatusWaitingOnQueue、TaskStatusBeingProcessed、TaskStatusCompleted。 |
| void Thread(ThreadId_t *pid) | 返回处理线程的线程ID。 |
| BOOL Wait(int iTimeInSeconds) | 将一个调用线程置于等待状态，直到任务结束或iTimeInSeconds时间到。如果一个任务在iTimeInSeconds时间内未完成，将返回FALSE，否则返回TRUE。 |
在此没有定义CThread类，定不定义它与理解其与CTask对象怎样交互并无关系，下表列出了两者是如何交互的：
处理CTask对象的步骤：
一个CTask对象被传递给CThread对象以便进行处理。
CThread对象将CTask对象放置于一个先来先服务队列中。
CThread对象将CTask对象状态设为 TaskStatusWaitingOnQueue。
CThread对象将CTask对象弹出等待队列。
CThread对象将CTask对象状态修改为 TaskStatusBeingProcessed。
CThread对象调用CTask对象的成员函数task执行相应任务。
CThread对象将CTask对象状态修改为 TaskStateCompleted。
下面是CThread类的函数列表：
<!-- @page { margin: 2cm } P { margin-bottom: 0.21cm } -->
| 函数 | 描述 |
| void CThread() | 构造函数，初始化对象数据并启动线程。 |
| void ~CThread() | 析构函数，结束线程并释放资源。 |
| BOOL Event(LPVOID lpvData) | 放置一数据块在事件堆栈或队列中，并通知对象线程要处理的数据已经准备好了。 |
| BOOL Event(CTask *pTask) | 放置一CTask对象在事件堆栈或队列中，并通知对象线程任务正待被执行。 |
| int GetEventsPending() | 返回事件堆栈中等待的事件数。 |
| ThreadId_t GetId() | 返回对象线程ID。 |
| DWORD GetErrorFlags() | 返回对象的错误标志。如果没有错误，会返回一个零值(NO_ERRORS)；如果有错误，就会设置以下的标志位：MUTEX_CREATION（未创建mutex对象）、EVENT_CREATION（未创建事件对象）、THREAD_CREATION（未创建对象的线程）、ILLEGAL_USE_OF_EVENT（非法使用Event成员函数）。 |
| BOOL PingThread(DWORD dwTimeoutMilli) | 判断对象的线程是否在运行。如果在运行返回TRUE，否则返回FALSE，超时以秒为单位。 |
| SetPriority(DWORD dwPriority) | 设置线程的优先级，只在Windows平台上有效。 |
| BOOL Start() | 开始对象线程。 |
| BOOL Stop() | 停止对象线程。 |
| void SetIdle(DWORD dwIdle) | 以毫秒为单位修改线程的空闲时间。 |
| SetThreadType(ThreadType_t typ,DWORD dwIdle) | 修改线程类型为ThreadTypeEventDriven或ThreadTypeIntervalDriven。 |
| m_mutex | 用于同步的mutex对象，参见CMutexClass。 |
| ThreadState_t ThreadState() | 返回线程状态：ThreadStateBusy（线程正在处理一个事件）、ThreadStateWaiting（线程正在等等一个新事件）、ThreadStateDown（线程未运行）、ThreadStateShutingDown（线程正在关闭）。 |
了解了支撑类之后，下面来看一下主类CThread，即最主要的工作线程类。CThread支持两种类型的线程：事件驱动的及间隔驱动的。事件驱动的线程是一种阻塞于事件对象、处于等待状态的线程，直至事件对象的状态由无信号转为有信号，当另一个线程把某项任务放入CThread对象的队列中时，一个新的事件就发生了，且会通过设置事件对象为有信号来通知对象线程。一旦有信号之后，线程被唤醒并从事件队列中弹出相应的任务，直至队列为空。
CThread对象为每个任务都调用OnTask成员函数，任务以先来先服务（FDFS）的顺序被执行，因此，第一个放入CThread对象队列中的任务会首先被执行，接着是第二个，如此下去。此时，mutex对象起着队列访问的同步作用，可在线程正在执行某项任务时，把另一个事件放入到队列中来。一旦队列为空，线程则重置事件对象为无信号状态并返回等待下一个事件对象。CThread类支持两种类型的事件驱动线程：特定的及非特定的，参见CTask。
为实现一个特定的线程，必须从CThread类派生出一个新类，这个派生的类应包括OnTask的一个重定义的实现，以处理对象数据类型。
#include "Thread.h"
class CIncrementThread : public CThread
{
public:
int counter;
virtual BOOL OnTask( LPVOID lpv )
{
ThreadId_t id;
GetId(&id);
if( lpv )
{
int *pInt = (int *)lpv;
//在此不能使用cout，输出会因为线程的原因而有所间断
printf("/tthread(%ld, counter+%d=%d, counter incremented/n",
id,*pInt,(counter+=*pInt));
}
return TRUE;
}
virtual BOOL OnTask()
{
ThreadId_t id;
GetId(&id);
//在此不能使用cout，输出会因为线程的原因而有所间断
m_mutex.Lock(); //保护计数变量
printf("/tthread(%ld, counter++= %d, counter incremented)/n",
id,(++counter));
m_mutex.Unlock();
return TRUE;
}
int GetValue()
{
int counterValue = 0;
m_mutex.Lock(); //保护计数变量
counterValue = counter;
m_mutex.Unlock();
return counter;
}
void Reset()
{
m_mutex.Lock();
counter = 0;
m_mutex.Unlock();
}
CIncrementThread(){counter=0;}
~CIncrementThread(){}
};
int main( int argc,
char *argv[])
{
//分配对象并开始线程
CIncrementThread MyThread;
int two=2;
while( MyThread.GetValue() < 20 )
{
MyThread.Event(); //增量加1
Sleep(100); //暂停根线程100毫秒
}
MyThread.Reset();
while( MyThread.GetValue() < 40 )
{
MyThread.Event(&two);
Sleep(100);
}
}
OUTPUT:
thread(5220, counter++= 1, counter incremented)
thread(5220, counter++= 2, counter incremented)
thread(5220, counter++= 3, counter incremented)
thread(5220, counter++= 4, counter incremented)
thread(5220, counter++= 5, counter incremented)
thread(5220, counter++= 6, counter incremented)
thread(5220, counter++= 7, counter incremented)
thread(5220, counter++= 8, counter incremented)
thread(5220, counter++= 9, counter incremented)
thread(5220, counter++= 10, counter incremented)
thread(5220, counter++= 11, counter incremented)
thread(5220, counter++= 12, counter incremented)
thread(5220, counter++= 13, counter incremented)
thread(5220, counter++= 14, counter incremented)
thread(5220, counter++= 15, counter incremented)
thread(5220, counter++= 16, counter incremented)
thread(5220, counter++= 17, counter incremented)
thread(5220, counter++= 18, counter incremented)
thread(5220, counter++= 19, counter incremented)
thread(5220, counter++= 20, counter incremented)
thread(5220, counter+2=2, counter incremented
thread(5220, counter+2=4, counter incremented
thread(5220, counter+2=6, counter incremented
thread(5220, counter+2=8, counter incremented
thread(5220, counter+2=10, counter incremented
thread(5220, counter+2=12, counter incremented
thread(5220, counter+2=14, counter incremented
thread(5220, counter+2=16, counter incremented
thread(5220, counter+2=18, counter incremented
thread(5220, counter+2=20, counter incremented
thread(5220, counter+2=22, counter incremented
thread(5220, counter+2=24, counter incremented
thread(5220, counter+2=26, counter incremented
thread(5220, counter+2=28, counter incremented
thread(5220, counter+2=30, counter incremented
thread(5220, counter+2=32, counter incremented
thread(5220, counter+2=34, counter incremented
thread(5220, counter+2=36, counter incremented
thread(5220, counter+2=38, counter incremented
thread(5220, counter+2=40, counter incremented
在上面的例子中，从CThread类中派生了一个CIncrementThread类，且重定义了OnTask()及OnTask(LPVOID)虚成员函数。在OnTask()的实现中，添加了一个对象计数变量，而OnTask的另一个成员函数接受一个指向整型值的指针，并将指针值添加到计数成员变量中。这个例子演示了一个线程可处理的两类事件，又因为计数变量可能会被不止一个线程访问，所以用了CThread::m_mutex对象来保证访问的独占性。
另外，在此的HAT是由CThread及CTask两者来实现的。
#include "Thread.h"
class CTaskIncrementer: public CTask
{
private:
int counter;
int incr;
public:
void SetIncr(int iValue)
{
m_mutex.Lock();
incr = iValue;
m_mutex.Unlock();
}
int GetIncrementValue()
{
int incrValue;
m_mutex.Lock();
incrValue=incr;
m_mutex.Unlock();
return incrValue;
}
int GetValue()
{
int counterValue = 0;
m_mutex.Lock(); //保护计数变量
counterValue = counter;
m_mutex.Unlock();
return counter;
}
BOOL Task()
{
ThreadId_t id;
Thread(&id);
m_mutex.Lock();
printf("/tthread(%ld, counter+%d=%d, counter incremented/n",
id,incr,(counter+=incr));
m_mutex.Unlock();
return TRUE;
}
CTaskIncrementer(){counter=0;}
~CTaskIncrementer(){}
};
int
main(int argc,
char *argv[])
{
CTaskIncrementer incr;
CThread thr;
incr.SetIncr(2);
while( incr.GetValue() < 40 ) thr.Event(&incr);
}
OUTPUT:
thread(5700, counter+2=2, counter incremented
thread(5700, counter+2=4, counter incremented
thread(5700, counter+2=6, counter incremented
thread(5700, counter+2=8, counter incremented
thread(5700, counter+2=10, counter incremented
thread(5700, counter+2=12, counter incremented
thread(5700, counter+2=14, counter incremented
thread(5700, counter+2=16, counter incremented
thread(5700, counter+2=18, counter incremented
thread(5700, counter+2=20, counter incremented
thread(5700, counter+2=22, counter incremented
thread(5700, counter+2=24, counter incremented
thread(5700, counter+2=26, counter incremented
thread(5700, counter+2=28, counter incremented
thread(5700, counter+2=30, counter incremented
thread(5700, counter+2=32, counter incremented
thread(5700, counter+2=34, counter incremented
thread(5700, counter+2=36, counter incremented
thread(5700, counter+2=38, counter incremented
thread(5700, counter+2=40, counter incremented
间隔驱动的线程是一种在预先定义的间隔时间上被唤醒的线程，它会检查所在环境是否发生了变化，并处理这些变化，之后休眠等待下一个间隔时间，接着再唤醒做同样的事。要实现一个间隔驱动的线程，需派生一个CThread类并重定义OnTask(LPVOID)。一旦线程实例化后，就可以用ThreadTypeIntervalDriven参数来调用SetThreadType成员函数，设置好以毫秒计的间隔。
#include "Thread.h"
class CIncrementThread : public CThread
{
public:
int counter;
virtual BOOL OnTask()
{
ThreadId_t id;
GetId(&id);
//在此不能使用cout，输出会因为线程的原因而有所间断
m_mutex.Lock(); //保护计数变量
printf("/tthread(%ld, counter++= %d, counter incremented)/n",
id,(++counter));
m_mutex.Unlock();
return TRUE;
}
int GetValue()
{
int counterValue = 0;
m_mutex.Lock(); //保护计数变量
counterValue = counter;
m_mutex.Unlock();
return counter;
}
void Reset()
{
m_mutex.Lock();
counter = 0;
m_mutex.Unlock();
}
CIncrementThread(){counter=0;}
~CIncrementThread(){}
};
int
main( int argc,
char *argv[] )
{
CIncrementThread thr;
thr->SetThreadType(ThreadTypeIntervalDriven,100);
Sleep(500);
}
OUTPUT:
thread(6104, counter++= 12, counter incremented)
thread(6104, counter++= 13, counter incremented)
thread(6104, counter++= 14, counter incremented)
thread(6104, counter++= 15, counter incremented)
thread(6104, counter++= 16, counter incremented)
结论
以上就是一个全功能的线程对象，且在Linux上做过测试，但没有在SunOS及其他Unix平台上测试过，不过应该也没问题。当在Windows上编译时，一定要代码生成选项上指定/Mt或/Mtd，表明你的程序是一个多线程程序，而下面则是Linux上的make文件。
CC=g++
LIBS=-lpthread -lrt
CFLAGS=-DSUNOS -DNANO_SECOND_SLEEP
OBJS=Thread.cpp EventClass.cpp MutexClass.cpp main.cpp
EXECS = thread
all: $(EXECS)
thread: $(OBJS)
$(CC) $(CFLAGS) -o thread $(OBJS) $(LIBS)
clean:; rm -f *.o $(EXECS)
871
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
