VC多线程实现线程间通信
用VC++实现多线程的调度和处理
用VC++实现多线程的调度和处理
毋小省
【期刊名称】《焦作大学学报》
【年(卷),期】2001(015)001
【摘要】详述了在Window95/98NT下的多任务、多进程和多线程的含义,基于MFC的用户界面线程和工作者线程的建立及终止,进程和线程的优先级问题以及多线程间的同步问题.
【总页数】3页(P57-59)
【作者】毋小省
【作者单位】焦作大学
【正文语种】中文
【中图分类】TP316.86
【相关文献】
1.基于VC++串口多线程通信的实现 [J], 岳明;何波贤;余博超;牟健
2.基于VC++的多线程聊天程序的设计与实现 [J], 潘军;张诗楠;王晓
3.MFC类库实现多线程的调度和处理 [J], 刘思程;余彬
4.MFC类库实现多线程的调度和处理 [J], 刘思程
5.基于VC++的多线程《计算机图形学》教学演示系统设计与实现 [J], 赵辉煌;魏书堤;陈坚祯;唐佳伟
因版权原因，仅展示原文概要，查看原文内容请购买。
c++线程间通信的几种方法
c++线程间通信的几种方法在C++中，多线程编程是非常常见的，而线程间通信则是必不可少的。
线程间通信是指在多个线程之间共享数据或者协调操作的过程。
以下是几种C++线程间通信的方法：1. 互斥量(mutex)：通过互斥量可以保证同一时刻只有一个线程可以访问被保护的资源。
当一个线程要对共享资源进行访问时，它需要先通过mutex进行加锁保护，当它完成访问后，需要将该锁释放，以便其他的线程可以访问共享资源。
2. 条件变量(condition variable)：条件变量是一种用于线程间等待和通知的机制，它提供了一种线程间同步的机制，允许一个线程等待另一个线程通知它某个特定条件已经满足。
在条件变量的使用过程中，通常需要和互斥量一起使用，以确保线程安全。
3. 信号量(semaphore)：信号量是一种用于线程间同步的机制，它允许多个线程在共享资源的同时进行操作，当资源被占用时，其他线程需要等待。
信号量分为二进制信号量和计数信号量两种，其中二进制信号量只有0和1两种状态，计数信号量可以有多种状态。
4. 原子操作(atomic operations)：原子操作是一种用于线程间同步的机制，它是一种可以被看作是不可分割的操作，要么全部执行，要么全部不执行。
在C++11之后，C++标准库提供了一些原子操作的模板类，如atomic_bool、atomic_int等，可以实现线程安全的计数器、状态标志等。
5. 线程池(thread pool)：线程池是一种将多个线程组织起来共同完成任务的机制，它可以避免线程创建和销毁的开销，提高了应用程序的性能。
线程池通常需要和任务队列一起使用，将任务添加到任务队列中，由线程池中的线程进行处理。
总之，在进行多线程编程时，线程间通信是必不可少的，这些方法各有优缺点，在实际应用中需要根据具体的场景和需求进行选择。
C#实现多线程的同步方法详解
C#实现多线程的同步⽅法详解本⽂主要描述在C#中线程同步的⽅法。
线程的基本概念⽹上资料也很多就不再赘述了。
直接接⼊主题，在多线程开发的应⽤中，线程同步是不可避免的。
在.Net框架中，实现线程同步主要通过以下的⼏种⽅式来实现，在MSDN的线程指南中已经讲了⼏种，本⽂结合作者实际中⽤到的⽅式⼀起说明⼀下。
1. 维护⾃由锁(InterLocked)实现同步2. 监视器（Monitor）和互斥锁（lock）3. 读写锁（ReadWriteLock)4. 系统内核对象1) 互斥(Mutex), 信号量(Semaphore), 事件(AutoResetEvent/ManualResetEvent)2) 线程池除了以上的这些对象之外实现线程同步的还可以使⽤Thread.Join⽅法。
这种⽅法⽐较简单，当你在第⼀个线程运⾏时想等待第⼆个线程执⾏结果，那么你可以让第⼆个线程Join进来就可以了。
⾃由锁(InterLocked)对⼀个32位的整型数进⾏递增和递减操作来实现锁，有⼈会问为什么不⽤++或--来操作。
因为在多线程中对锁进⾏操作必须是原⼦的，⽽++和--不具备这个能⼒。
InterLocked类还提供了两个另外的函数Exchange, CompareExchange⽤于实现交换和⽐较交换。
Exchange操作会将新值设置到变量中并返回变量的原来值: int oVal = InterLocked.Exchange(ref val, 1)。
监视器(Monitor)在MSDN中对Monitor的描述是: Monitor 类通过向单个线程授予对象锁来控制对对象的访问。
Monitor类是⼀个静态类因此你不能通过实例化来得到类的对象。
Monitor 的成员可以查看MSDN，基本上Monitor的效果和lock是⼀样的，通过加锁操作Enter设置临界区，完成操作后使⽤Exit操作来释放对象锁。
不过相对来说Monitor的功能更强，Moniter可以进⾏测试锁的状态，因此你可以控制对临界区的访问选择，等待or离开, ⽽且Monitor还可以在释放锁之前通知指定的对象，更重要的是使⽤Monitor可以跨越⽅法来操作。
linux线程间通信的几种方法
linux线程间通信的几种方法Linux是一种开源的操作系统，它支持多线程编程，因此线程间通信是非常重要的。
线程间通信是指在多个线程之间传递数据或信息的过程。
在Linux中，有多种方法可以实现线程间通信，本文将介绍其中的几种方法。
1. 信号量信号量是一种用于线程间同步和互斥的机制。
它可以用来控制对共享资源的访问。
在Linux中，信号量是由sem_t类型的变量表示的。
它有三个主要的操作：初始化、P操作和V操作。
初始化操作用于初始化信号量的值。
P操作用于获取信号量，如果信号量的值为0，则线程会被阻塞，直到信号量的值大于0。
V操作用于释放信号量，将信号量的值加1。
下面是一个使用信号量实现线程间通信的例子：```#include <stdio.h>#include <pthread.h>#include <semaphore.h>sem_t sem;void *thread1(void *arg){sem_wait(&sem);printf("Thread 1\n");sem_post(&sem);pthread_exit(NULL);}void *thread2(void *arg){sem_wait(&sem);printf("Thread 2\n");sem_post(&sem);pthread_exit(NULL);}int main(){pthread_t t1, t2;sem_init(&sem, 0, 1);pthread_create(&t1, NULL, thread1, NULL); pthread_create(&t2, NULL, thread2, NULL); pthread_join(t1, NULL);pthread_join(t2, NULL);sem_destroy(&sem);return 0;}```在这个例子中，我们创建了两个线程，它们都需要获取信号量才能执行。
c语言线程间通信的几种方法
c语言线程间通信的几种方法一、全局变量全局变量是最简单的线程间通信方法之一。
不同的线程可以通过访问和修改同一个全局变量来实现信息的交换。
在使用全局变量时，需要注意对全局变量的访问同步问题，以避免数据竞争和不一致性的问题。
二、互斥锁（Mutex）互斥锁是一种同步原语，用于保护共享资源的访问。
线程在访问共享资源之前，首先要获取互斥锁，如果互斥锁已经被其他线程获取，则当前线程会被阻塞，直到互斥锁被释放。
通过对互斥锁的加锁和解锁操作，可以保证共享资源的访问是互斥的，从而避免了数据竞争和不一致性的问题。
三、条件变量（Condition Variable）条件变量是一种同步原语，用于在多线程环境下实现线程之间的协调。
条件变量通常与互斥锁一起使用，用于实现等待和唤醒的操作。
一个线程可以通过条件变量等待某个条件的发生，而另一个线程可以通过条件变量发送信号来唤醒等待的线程。
四、信号量（Semaphore）信号量是一种同步原语，用于实现线程之间的同步和互斥。
信号量可以用来控制对共享资源的访问数量。
当信号量的值大于0时，线程可以继续访问共享资源；当信号量的值等于0时，线程会被阻塞，直到信号量的值大于0。
通过对信号量的P操作（减操作）和V操作（加操作），可以实现线程的同步和互斥。
五、消息队列（Message Queue）消息队列是一种在多线程环境下进行线程间通信的机制。
不同的线程可以通过向消息队列发送消息和从消息队列接收消息来进行通信。
消息队列可以实现线程之间的异步通信，提高系统的响应速度和并发性能。
六、管道（Pipe）管道是一种常用的线程间通信机制，可以用于在父子进程或者兄弟进程之间进行通信。
在多线程环境下，可以使用管道来实现线程之间的通信。
一个线程可以通过管道的写端向管道发送数据，另一个线程可以通过管道的读端从管道接收数据。
通过管道的读写操作，可以实现线程之间的数据交换。
以上就是几种常用的C语言线程间通信方法。
不同的方法适用于不同的场景，开发者可以根据具体的需求选择合适的线程间通信方法。
c++线程同步的几种方法
c++线程同步的几种方法在多线程编程中，线程同步是一个关键问题，它涉及到不同线程之间的数据访问和操作。
如果不正确地处理同步，可能会导致数据不一致、竞态条件等问题。
在 C 语言中，有多种方法可以实现线程同步，下面我们将介绍几种常用的方法。
1. 互斥锁（Mutex）互斥锁是一种常用的线程同步机制，它用于保护共享资源，防止多个线程同时访问和修改同一资源，导致数据不一致。
在使用互斥锁时，必须确保每次只有一个线程能够获得锁，并在完成后释放锁，以避免死锁。
示例代码：```cmutex_t mutex;void* threadFunction(void* arg) {mutex_lock(&mutex); // 获取锁// 访问或修改共享资源mutex_unlock(&mutex); // 释放锁return NULL;}```2. 信号量（Semaphore）信号量是一种用于控制线程数目的同步机制，通常用于限制同时执行的线程数。
它是一个计数器，可以用于表示可以同时执行线程的数目。
当请求的线程数目超过信号量的值时，只有部分线程能够被允许执行。
示例代码：```csem_t semaphore;void* threadFunction(void) {sem_wait(&semaphore); // 等待信号量释放// 执行线程任务return NULL;}```3. 条件变量（Condition Variable）条件变量是一种特殊的同步机制，它允许一个或多个线程在特定条件下等待其他线程的操作。
它通常与互斥锁和信号量一起使用，以实现更复杂的同步逻辑。
示例代码：```ccondition_t condition;void* threadFunction(void) {while (!condition_wait(&condition)) {// 等待条件满足}// 执行线程任务condition_signal(&condition); // 通知其他等待的线程return NULL;}```以上是 C 语言中几种常用的线程同步方法。
Visual C++线程同步技术剖析临界区,时间,信号量,互斥量
Visual C++线程同步技术剖析:临界区，时间，信号量，互斥量摘要：多线程同步技术是计算机软件开发的重要技术，本文对多线程的各种同步技术的原理和实现进行了初步探讨。
关键词：VC++6.0；线程同步；临界区；事件；互斥；信号量；正文使线程同步在程序中使用多线程时，一般很少有多个线程能在其生命期内进行完全独立的操作。
更多的情况是一些线程进行某些处理操作，而其他的线程必须对其处理结果进行了解。
正常情况下对这种处理结果的了解应当在其处理任务完成后进行。
如果不采取适当的措施，其他线程往往会在线程处理任务结束前就去访问处理结果，这就很有可能得到有关处理结果的错误了解。
例如，多个线程同时访问同一个全局变量，如果都是读取操作，则不会出现问题。
如果一个线程负责改变此变量的值，而其他线程负责同时读取变量内容，则不能保证读取到的数据是经过写线程修改后的。
为了确保读线程读取到的是经过修改的变量，就必须在向变量写入数据时禁止其他线程对其的任何访问，直至赋值过程结束后再解除对其他线程的访问限制。
象这种保证线程能了解其他线程任务处理结束后的处理结果而采取的保护措施即为线程同步。
线程同步是一个非常大的话题，包括方方面面的内容。
从大的方面讲，线程的同步可分用户模式的线程同步和内核对象的线程同步两大类。
用户模式中线程的同步方法主要有原子访问和临界区等方法。
其特点是同步速度特别快，适合于对线程运行速度有严格要求的场合。
内核对象的线程同步则主要由事件、等待定时器、信号量以及信号灯等内核对象构成。
由于这种同步机制使用了内核对象，使用时必须将线程从用户模式切换到内核模式，而这种转换一般要耗费近千个CPU周期，因此同步速度较慢，但在适用性上却要远优于用户模式的线程同步方式。
临界区临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。
如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。
c语言线程间的通信
c语言线程间的通信
在C语言中，线程间的通信可以通过多种方式实现，包括以下几种常用方法：
1. 共享内存：通过在多个线程之间共享一块内存区域来进行数据通信。
可以使用标准库中的`shmget()`函数创建共享内存，然后使用`mmap()`函数将共享内存映射到各个线程的地址空间。
2. 信号量：通过信号量控制多个线程的访问权限，从而实现线程间的同步和互斥。
可以使用`sem_init()`函数初始化一个信号量，然后使用`sem_wait()`和`sem_post()`函数进行等待和释放操作。
3. 互斥锁：通过互斥锁保护共享资源的访问，从而实现线程间的互斥访问。
可以使用`pthread_mutex_init()`函数初始化一个互斥锁，然后使用`pthread_mutex_lock()`和`pthread_mutex_unlock()`函数对互斥锁进行加锁和解锁操作。
4. 条件变量：通过条件变量实现线程间的等待和唤醒操作，从而实现线程间的同步。
可以使用`pthread_cond_init()`函数初始化一个条件变量，然后使用`pthread_cond_wait()`和
`pthread_cond_signal()`函数进行等待和唤醒操作。
5. 管道：通过管道在多个线程之间传输数据。
可以使用
`pipe()`函数创建一个管道，然后使用`read()`和`write()`函数进行读写操作。
以上是常见的几种线程间通信的方法，具体选择哪种方法取决于具体的需求和场景。
C#线程间互相通信
C#线程间互相通信 C#线程间互相通信主要⽤到两个类：AutoResetEvent和ManualResetEvent. ⼀、AutoResetEvent AutoResetEvent 允许线程通过发信号互相通信，线程通过调⽤ AutoResetEvent 上的 WaitOne 来等待信号。
如果 AutoResetEvent 为⾮终⽌状态，则线程会被阻⽌，并等待当前控制资源的线程通过调⽤ Set 来通知资源可⽤。
下⾯我⽤吃快餐的例⼦来说明这个问题，吃快餐的时候都会排队付款，收银员发送收款通知，客户依次付钱，代码如下： 复制代码 1 class Program 2 { 3 //若要将初始状态设置为终⽌，则为 true;若要将初始状态设置为⾮终⽌，则为 false 4 static AutoResetEvent autoResetEvent = new AutoResetEvent（false）； 5 6 static void Main（string[] args） 7 { 8 Thread t1 = new Thread（（） => 9 { 10 Console.WriteLine（"客户1在排队等待付钱…"）； 11 12 //客户1调⽤AutoResetEvent上的WaitOne来等待付钱通知 13 autoResetEvent.WaitOne（）； 14 Console.WriteLine（"通知来了，客户1付钱"）； 15 }）； 16 t1.IsBackground = true; 17 t1.Start（）； 18 19 Pay（）；//发送通知 20 Console.ReadKey（）； 21 } 22 23 static void Pay（） 24 { 25 string tip = Console.ReadLine（）； 26 if （tip == "next"） 27 { 28 autoResetEvent.Set（）；//收银员发送付钱通知，通过调⽤Set来通知客户付钱 29 } 30 } 31 } 复制代码 运⾏在屏幕中打印： 客户1在排队等待付钱… 等收银员说"next"的时候，向客户1发送付钱通知（autoResetEvent.Set（）），屏幕打印： 客户1在排队等待付钱… next 通知来了，客户1付钱！ AutoResetEvent类⼀次只能通知⼀个等待的线程，且通知⼀次过后会⽴即将AutoResetEvent对象的状态置为false,也就是如果有两个客户都在等待收银员通知，AutoResetEvent对象的set⽅法只能通知到第⼀个客户，代码和效果如下： 复制代码 1 class Program 2 { 3 //若要将初始状态设置为终⽌，则为 true;若要将初始状态设置为⾮终⽌，则为 false. 4 static AutoResetEvent autoResetEvent = new AutoResetEvent（false）； 5 6 static void Main（string[] args） 7 { 8 Thread t1 = new Thread（（） => 9 { 10 Console.WriteLine（"客户1在排队等待付钱…"）； 11 12 //客户1调⽤AutoResetEvent上的WaitOne来等待付钱通知 13 autoResetEvent.WaitOne（）； 14 Console.WriteLine（"通知来了，客户1付钱"）； 15 }）； 16 t1.IsBackground = true; 17 t1.Start（）； 18 19 Thread t2 = new Thread（（） => 20 { 21 Console.WriteLine（"客户2在排队等待付钱…"）； 22 23 //客户2调⽤AutoResetEvent上的WaitOne来等待付钱通知 24 autoResetEvent.WaitOne（）； 25 Console.WriteLine（"通知来了，客户2付钱！"）； 26 }）； 27 t2.IsBackground = true; 28 t2.Start（）； 29 30 Pay（）；//发送通知 31 32 Console.ReadKey（）； 33 } 34 35 static void Pay（） 36 { 37 string tip = Console.ReadLine（）； 38 if （tip == "next"） 39 { 40 autoResetEvent.Set（）；//收银员发送付钱通知，通过调⽤Set来通知客户付钱 41 } 42 } 43 } 复制代码 运⾏后屏幕打印： 客户1在排队等待付钱… 客户1在排队等待付钱… next 通知来了，客户1付钱！ 这就说明在通知完客户1后，autoResetEvent 的状态⼜被置为了false,这时如果要通知到客户2,就需要在通知完客户1后，再执⾏⼀次通知，在线程1中加上⼀⾏代码，如下： 复制代码 1 Thread t1 = new Thread（（） => 2 { 3 Console.WriteLine（"客户1在排队等待付钱…"）； 4 5 //客户1调⽤AutoResetEvent上的WaitOne来等待付钱通知 6 autoResetEvent.WaitOne（）； 7 Console.WriteLine（"通知来了，客户1付钱"）； 8 9 autoResetEvent.Set（）；//让其再通知下个客户 10 }）； 复制代码 运⾏后屏幕打印： 客户1在排队等待付钱… 客户1在排队等待付钱… next 通知来了，客户1付钱！ 通知来了，客户2付钱！ 这也就说明每调⽤⼀次Set,只有⼀个线程会解除等待，换句话说，有多少个线程就要调⽤多少次Set,线程才会全部继续。
c++线程间通信的几种方法
c++线程间通信的几种方法C++是一种广泛使用的编程语言，而线程的使用在C++程序中也是很常见的。
由于多线程程序中存在多个线程同时运行的问题，线程间的通信也就变得至关重要。
本文将介绍C++中线程间通信的几种方法。
1.共享变量共享变量是最简单的线程间通信方式之一。
其原理是多个线程访问同一个变量，如果一个线程修改了该变量，则其他线程也能读到该变量的修改值。
需要注意的是，由于共享变量的修改是非线程安全的，因此在使用共享变量时需要使用线程同步机制来保证线程安全。
2.信号量信号量是另一种常用的线程间通信方式。
其原理是一个线程在执行完一定任务后，发送一个信号量通知其他线程可以执行了。
一个生产者线程向一个缓冲队列发送一个信号量表示队列已经有了数据，消费者线程则根据这个信号量来消耗队列中的数据。
需要注意的是，使用信号量需要保证其线程同步。
在生产者线程中设置信号量的值之后，需要将其置0，防止其他线程持续访问。
3.消息队列消息队列是一种线程间通信方式，可以在不同线程之间传递数据。
其原理是用于发送消息的线程将消息添加到队列中，接受消息的线程从队列中读取消息。
需要注意的是，消息队列需要使用互斥锁或信号量来保证线程同步。
4.管道管道是一种线程间通信方式，适用于有父子进程或兄弟进程的情况。
其原理是在两个进程之间创建一个单向的管道，一个进程写入数据到管道中，另一个进程从管道中读取数据。
管道可以通过系统调用pipe()来创建。
需要注意的是，管道只能在亲缘关系进程之间使用，而且只能进行单向通信。
5.套接字套接字是一种通用的线程间通信方式，适用于不同计算机之间的通信。
其原理是将数据通过TCP/IP协议传输到网络中的另一个套接字，然后将此套接字中的数据传递到目标线程中。
需要注意的是，套接字通信需要使用互斥锁或信号量来保证线程同步。
6.事件事件机制是一种线程间通信方式，其原理是一个线程产生一个事件，其他线程在等待该事件完成后才能继续执行。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
当前流行的Windows操作系统能同时运行几个程序(独立运行的程序又称之为进程)，对于同一个程序，它又可以分成若干个独立的执行流，我们称之为线程，线程提供了多任务处理的能力。
用进程和线程的观点来研究软件是当今普遍采用的方法，进程和线程的概念的出现，对提高软件的并行性有着重要的意义。
现在的大型应用软件无一不是多线程多任务处理，单线程的软件是不可想象的。
因此掌握多线程多任务设计方法对每个程序员都是必需要掌握的。
本实例针对多线程技术在应用中经常遇到的问题，如线程间的通信、同步等，分别进行探讨，并利用多线程技术进行线程之间的通信，实现了数字的简单排序。
一、实现方法1、理解线程要讲解线程，不得不说一下进程，进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它系统资源组成。
进程在运行时创建的资源随着进程的终止而死亡。
线程的基本思想很简单，它是一个独立的执行流，是进程内部的一个独立的执行单元，相当于一个子程序，它对应于Visual C++中的CwinThread类对象。
单独一个执行程序运行时，缺省地包含的一个主线程，主线程以函数地址的形式出现，提供程序的启动点，如main （）或WinMain（）函数等。
当主线程终止时，进程也随之终止。
根据实际需要，应用程序可以分解成许多独立执行的线程，每个线程并行的运行在同一进程中。
一个进程中的所有线程都在该进程的虚拟地址空间中，使用该进程的全局变量和系统资源。
操作系统给每个线程分配不同的CPU时间片，在某一个时刻，CPU只执行一个时间片内的线程，多个时间片中的相应线程在CPU内轮流执行，由于每个时间片时间很短，所以对用户来说，仿佛各个线程在计算机中是并行处理的。
操作系统是根据线程的优先级来安排CPU的时间，优先级高的线程优先运行，优先级低的线程则继续等待。
线程被分为两种：用户界面线程和工作线程（又称为后台线程）。
用户界面线程通常用来处理用户的输入并响应各种事件和消息，其实，应用程序的主执行线程CWinAPP对象就是一个用户界面线程，当应用程序启动时自动创建和启动，同样它的终止也意味着该程序的结束，进程终止。
工作线程用来执行程序的后台处理任务，比如计算、调度、对串口的读写操作等，它和用户界面线程的区别是它不用从CWinThread类派生来创建，对它来说最重要的是如何实现工作线程任务的运行控制函数。
工作线程和用户界面线程启动时要调用同一个函数的不同版本；最后需要读者明白的是，一个进程中的所有线程共享它们父进程的变量，但同时每个线程可以拥有自己的变量。
2、线程的管理和操作（一）线程的启动创建一个用户界面线程，首先要从类CwinThread产生一个派生类，同时必须使用DECLARE_DYNCREATE和IMPLEMENT_DYNCREATE来声明和实现这个CwinThread派生类。
第二步是根据需要重载该派生类的一些成员函数如：ExitInstance（）、InitInstance（）、OnIdle（）、PreTranslateMessage（）等函数。
最后调用AfxBeginThread()函数的一个版本：CWinThread* AfxBeginThread( CRuntimeClass* pThreadClass, int nPriority = THREAD_PRIORITY_NORMAL, UINT nStackSize = 0, DWORD dwCreateFlags = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL ) 启动该用户界面线程，其中第一个参数为指向定义的用户界面线程类指针变量，第二个参数为线程的优先级，第三个参数为线程所对应的堆栈大小，第四个参数为线程创建时的附加标志，缺省为正常状态，如为CREATE_SUSPENDED则线程启动后为挂起状态。
对于工作线程来说，启动一个线程，首先需要编写一个希望与应用程序的其余部分并行运行的函数如Fun1()，接着定义一个指向CwinThread对象的指针变量*pThread,调用AfxBeginThread(Fun1,param,priority)函数，返回值赋给pThread变量的同时一并启动该线程来执行上面的Fun1（）函数，其中Fun1是线程要运行的函数的名字，也既是上面所说的控制函数的名字，param是准备传送给线程函数Fun1的任意32位值，priority则是定义该线程的优先级别，它是预定义的常数，读者可参考MSDN。
（二）线程的优先级以下的CwinThread类的成员函数用于线程优先级的操作：int GetThreadPriority（）；BOOL SetThradPriority（）(int nPriority)；上述的二个函数分别用来获取和设置线程的优先级，这里的优先级，是相对于该线程所处的优先权层次而言的，处于同一优先权层次的线程，优先级高的线程先运行；处于不同优先权层次上的线程，谁的优先权层次高，谁先运行。
至于优先级设置所需的常数，自己参考MSDN就可以了，要注意的是要想设置线程的优先级，这个线程在创建时必须具有THREAD_SET_INFORMA TION访问权限。
对于线程的优先权层次的设置，CwinThread类没有提供相应的函数，但是可以通过Win32 SDK函数GetPriorityClass（）和SetPriorityClass （）来实现。
（三）线程的悬挂和恢复CWinThread类中包含了应用程序悬挂和恢复它所创建的线程的函数，其中SuspendThread（）用来悬挂线程，暂停线程的执行；ResumeThread（）用来恢复线程的执行。
如果你对一个线程连续若干次执行SuspendThread（），则需要连续执行相应次的ResumeThread（）来恢复线程的运行。
（四）结束线程终止线程有三种途径，线程可以在自身内部调用AfxEndThread()来终止自身的运行；可以在线程的外部调用BOOL TerminateThread( HANDLE hThread, DWORD dwExitCode )来强行终止一个线程的运行，然后调用CloseHandle（）函数释放线程所占用的堆栈；第三种方法是改变全局变量，使线程的执行函数返回，则该线程终止。
下面以第三种方法为例，给出部分代码：//////////////////////////////////////////////////////////////////////CtestView message handlers/////Set to True to end threadBool bend=FALSE;//定义的全局变量，用于控制线程的运行；//The Thread Function；UINT ThreadFunction(LPVOID pParam)//线程函数{while(!bend){Beep(100,100);Sleep(1000);}return 0;}/////////////////////////////////////////////////////////////CwinThread *pThread;HWND hWnd;V oid CtestView::OninitialUpdate(){hWnd=GetSafeHwnd();pThread=AfxBeginThread(ThradFunction,hWnd);//启动线程pThread->m_bAutoDelete=FALSE;//线程为手动删除Cview::OnInitialUpdate();}////////////////////////////////////////////////////////////////V oid CtestView::OnDestroy(){bend=TRUE;//改变变量，线程结束WaitForSingleObject(pThread->m_hThread,INFINITE);//等待线程结束delete pThread;//删除线程Cview::OnDestroy();}3、线程之间的通信通常情况下，一个次级线程要为主线程完成某种特定类型的任务，这就隐含着表示在主线程和次级线程之间需要建立一个通信的通道。
一般情况下，有下面的几种方法实现这种通信任务：使用全局变量（上一节的例子其实使用的就是这种方法）、使用事件对象、使用消息。
这里我们主要介绍后两种方法。
（一）利用用户定义的消息通信在Windows程序设计中，应用程序的每一个线程都拥有自己的消息队列，甚至工作线程也不例外，这样一来，就使得线程之间利用消息来传递信息就变的非常简单。
首先用户要定义一个用户消息，如下所示：#define WM_USERMSG WMUSER+100；在需要的时候，在一个线程中调用：：PostMessage((HWND)param,WM_USERMSG,0,0)或CwinThread::PostThradMessage（）来向另外一个线程发送这个消息，上述函数的四个参数分别是消息将要发送到的目的窗口的句柄、要发送的消息标志符、消息的参数WPARAM和LPARAM。
下面的代码是对上节代码的修改，修改后的结果是在线程结束时显示一个对话框，提示线程结束：UINT ThreadFunction(LPVOID pParam){while(!bend){Beep(100,100);Sleep(1000);}：：PostMessage(hWnd,WM_USERMSG,0,0)；return 0;}////////WM_USERMSG消息的响应函数为OnThreadended(WPARAM wParam,LPARAM lParam)LONG CTestView::OnThreadended(WPARAM wParam,LPARAM lParam){AfxMessageBox("Thread ended.");Retrun 0;}上面的例子是工作者线程向用户界面线程发送消息，对于工作者线程，如果它的设计模式也是消息驱动的，那么调用者可以向它发送初始化、退出、执行某种特定的处理等消息，让它在后台完成。
在控制函数中可以直接使用：：GetMessage()这个SDK函数进行消息分检和处理，自己实现一个消息循环。
GetMessage()函数在判断该线程的消息队列为空时，线程将系统分配给它的时间片让给其它线程，不无效的占用CPU的时间，如果消息队列不为空，就获取这个消息，判断这个消息的内容并进行相应的处理。
（二）用事件对象实现通信在线程之间传递信号进行通信比较复杂的方法是使用事件对象，用MFC的Cevent类的对象来表示。