win32API多线程编程

最新推荐文章于 2021-06-23 16:45:35 发布

fengruoying93

最新推荐文章于 2021-06-23 16:45:35 发布

阅读量845

点赞数 2

分类专栏： Win32

原文链接：https://blog.csdn.net/gengshenghong/article/details/6945216

版权

Win32 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

原文1：https://blog.csdn.net/gengshenghong/article/details/6945216

原文2：https://www.cnblogs.com/Tony100K/p/11758936.html

Ref:

MSDN: http://msdn.microsoft.com/zh-cn/library/y6h8hye8(v=VS.100)

一、win32多线程的创建

Win32多线程的创建方法主要有：

（1）CreateThread()

（2）_beginthread()&&_beginthreadex()

（3）AfxBeginThread()

（4）CWinThread类

1、CreateThread()

百度百科：http://baike.baidu.com/view/1191444.htm

函数原型：

HANDLE CreateThread(
　　LPSECURITY_ATTRIBUTES lpThreadAttributes,
　　DWORD dwStackSize,
　　LPTHREAD_START_ROUTINE lpStartAddress,
　　LPVOID lpParameter,
　　DWORD dwCreationFlags,
　　LPDWORD lpThreadId);
}

头文件：Windows.h

CreateThread是Win32提供的创建线程的最基础的API，用于在主线程上创建一个线程。返回一个HANDLE句柄（内核对象）。

参数简要说明：

lpThreadAttributes：线程属性，用于设置线程的属性，NULL表示使用默认的设置。dwStackSize：线程堆栈大小，使用0采用默认设置，windows会根据需要动态增加堆栈大小。lpStartAddress：指向线程函数的指针。lpParameter：向线程函数传递的参数。dwCreationFlags：线程标志，CREATE_SUSPENDED表示创建一个挂起的线程，0表示创建后立即激活线程。lpThreadId，先线程的ID（输出参数）。

创建线程的代码：

#include "stdafx.h"
#include <Windows.h>
 
DWORD WINAPI ThreadProc(LPVOID lpParam)
{
	printf("sub thread started\n");
	printf("sub thread finished\n");
	return 0;
}
 
int main(int argc, char* argv[])
{
	DWORD threadID;
	HANDLE hThread;
	hThread = CreateThread(NULL,0,ThreadProc,NULL,0,&threadID);	// 创建线程
 
	return 0;
}

如果直接使用上面的代码，那么很可能没有任何输出，这是由于主线程创建了子线程后主线程继续向下运行，子线程还没来得及执行里面的代码主线程可能就结束了。这就需要另一个API来进行同步：WaitForSingleObject()。

与之对应的还有WaitForMultipleObjects，用于同步一组内核对象。（参考http://msdn.microsoft.com/zh-cn/site/ms686360获取所有的同步函数（Synchronization Functions）的使用。

WaitForSingleObject原型：DWORD WINAPI WaitForSingleObject(__in HANDLE hHandle, __in DWORD dwMilliseconds);其中，第一个参数是要等待的内核对象的句柄，第二个参数是设置等待超时时间，可以设置为INFINITE，表示一直等待直到有信号触发。

在内核对象使用完毕后，一般需要关闭，使用CloseHandle()函数，参数为内核对象句柄。

所以，以下是一个最基本的使用CreateThread的例子：

#include "stdafx.h"
#include <Windows.h>
 
DWORD WINAPI ThreadProc(LPVOID lpParam)
{
	printf("sub thread started\n");
	// TODO: Add your thread code here.
	printf("sub thread finished\n");
	return 0;
}
 
int main(int argc, char* argv[])
{
	DWORD threadID;
	HANDLE hThread;
	hThread = CreateThread(NULL,0,ThreadProc,NULL,0,&threadID);	// 创建线程
	
	WaitForSingleObject(hThread,INFINITE);
	CloseHandle(hThread);	// 关闭内核对象
	
	return 0;
}

2、_beginthread()&&_beginthreadex()

百度百科：http://baike.baidu.com/view/3029167.htm

MSDN：http://msdn.microsoft.com/zh-cn/library/kdzttdcb.aspx

函数原型：

uintptr_t _beginthread( // NATIVE CODE
   void( __cdecl *start_address )( void * ),
   unsigned stack_size,
   void *arglist 
);

头文件：process.h

参数说明：第一个参数是线程函数的指针，第二个参数是堆栈大小，第三个参数是要传递给线程函数的参数列表。返回值也是线程句柄（关于更多说明，参考MSDN)。
同样，对于_beginthread()的同步，和CreateThread一样可以使用WaitForSingleObject函数，CloseHandle()关闭内核对象。另外，_beginthread()的线程函数是无返回值类型的，可以使用_endthread()在线程函数中结束线程。

下面是一个使用_beginthread()的基本的例子：

#include "stdafx.h"
#include <Windows.h>
#include <process.h>
 
void __cdecl ThreadProc(void *para)
{
    printf("sub thread started\n");
	// TODO: Add your thread code here.
	printf("sub thread finished\n");
	_endthread();	// 可以省略，隐含会调用。
}
 
int main(int argc, char* argv[])
{
	HANDLE hThread = (HANDLE)_beginthread(ThreadProc, 0, NULL);
 
	WaitForSingleObject(hThread,INFINITE);
	CloseHandle(hThread);
}

另外，还有一个函数_beginthreadex()，可以简单的认为_beginthread()为其简化版，所以更多的时候是使用更简单的_beginthread()了。
说明：在MSDN中可以看到一句很重要的提示，内容为“For an executable file linked with Libcmt.lib, do not call the Win32 ExitThread API; this prevents the run-time system from reclaiming allocated resources. _endthread and _endthreadex reclaim allocated thread resources and then call ExitThread.”，简单翻译就是说，对于链接Libcmt.lib的可执行程序，不要使用Win32的线程退出函数(ExitThread)，这会阻止运行时系统回收分配的资源，应该使用_endthread，它能回收分配的线程资源然后调用ExitThread。这个问题看似没有提到CreateThread()，但是其实有关，这就是经常看到有些资料上坚决的说到”不要使用CreateThread创建线程，否则会内存泄漏“的来源了。
问题引出：CreateThread的内存泄漏问题（CreateThread和_beginthread的区别）

(1) _beginthread也是通过CreateThread来创建线程的，只是_beginthread对其进行了一些封装，将相关”资源“通过线程的本地存储（TLS）传递给了线程函数的参数，然后在调用_endthread的时候，会将这些保存的资源进行释放。

(2) 并不是所有的使用CreateThread的情况都会有内存泄漏。看了很多人的文章，只有http://wenku.baidu.com/view/adede4ec4afe04a1b071dea4.html的分析是最清晰的，我已经转到http://dl.dbank.com/c03ljl2iud了，可下载查看（版权归原作者所有）。

总之，建议是使用_beginthread取代CreateThread来创建线程。

3、AfxBeginThread()：

很显然，这是MFC中的Afx系列函数，一个在MFC中创建线程的全局函数。由于现在也不怎么用MFC了，这里就不多说了。

4、CWinThread类：

很显然，是MFC中创建线程的类，同上，不多说了。

5、补充内容

关于WaitForMultipleObjects在_beginthread无法使用的问题

问题：使用_beginthread创建多个线程，无法使用WaitForMultipleObjects来进行同步。

这个问题可以用下面的例子来测试：

#include "stdafx.h"
#include <Windows.h>
#include <process.h>
 
void __cdecl ThreadProc(void *para)
{
	printf("sub thread started\n");
	// TODO: Add your thread code here.
	printf("sub thread finished\n");
	_endthread();	// 可以省略，隐含会调用。
}
 
int main(int argc, char* argv[])
{
	DWORD threadID;
	HANDLE hThread[10];
	for(int i =0;i<10;i++)
		hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL);
 
	WaitForMultipleObjects(10, hThread,TRUE,INFINITE);		//无法同步所有线程！
	for(int i = 0;i<10;i++) {
		CloseHandle(hThread);
	}
}

期望的结果是程序能输出10次的线程创建结束的消息，但是实际运行发现，无法达到这么多次数。为何？这是因为WaitForMultipleObjects在这里无法正常工作。原因是：
_endthread()在结束线程的时候，会自动调用CloseHandle关闭内核对象。这就容易解释了，如果提前关闭了内核对象，WaitForMultipleObjects会返回错误。那么有没有专门用于_beginthread创建的线程的同步方法呢，就我目前所知，好象是没有的！要解决这里的问题，可以分别调用WaitForSingleObject来同步，当然，使用其他一些变相的方法也是可以的，另外，上面的CloseHandle当然就可以不用再调用了。

总结：看来_beginthread也不是那么好用。:）

二、创建执行挂起终止

CreateThread(NULL, 0, FunOne, (void*)&input, CREATE_SUSPENDED, NULL);
安全属性栈大小线程函数参数指针附加标志 ID号(32位int指针)
附加标志为0 创建即可执行
附加标志为CREATE_SUSPENDED 创建就要挂起
ResumeThread(句柄) 挂起计数器-1,为0则进行
SuspendThread(句柄) 挂起计数器+1
TerminateThread(hand1, 1) 第二个参数为exitcode
调用SetThreadPriority函数设置线程的相对优先级，例如
Bool SetThreadPriority (HANDLE hPriority , int nPriority)
参数hPriority 指向待设置的线程句柄
nPriority 是线程的相对优先级，可以是以下的值:
空闲：THREAD - PRIORITY- IDLE 15
最低线程：THREAD - PRIORITY- LOWEST 2
低于正常线程：THREAD - PRIORITY- BELOW- NORMAL 1
正常线程：THREAD - PRIORITY- NORMAL 0
高于正常线程：THREAD - PRIORITY- ABOVE – NORMAL -1
最高线程：THREAD - PRIORITY- HIGHEST -2
关键时间：THREAD - PRIORITY- TIME – CRITICAL -15
挂起与恢复函数原型
DWORD SuspendThread(HANDLE hThread)；
挂起指定的线程（慎用，不处理同步对象）
如果函数执行成功，则线程的执行被终止
每次调用SuspendThread() 函数，线程将挂起计数器的值增1

DWORD ResumeThread(HANDLE hThread)；
结束线程的挂起状态来执行这个线程
每次调用ResumeThread() 函数，线程将挂起计数器的值减1
若挂起计数器的值为0，则不会再减

#include "stdio.h"
#include <windows.h> 
#include <iostream> 
using namespace std;

//简单的多线程创建、执行、挂起、终止的程序例子。

DWORD WINAPI FunOne(LPVOID param) {
    while (true)
    {
        Sleep(1000);
        cout << "hello! ";
        //cout<<"hello! "<<*((int*)param); 
    }
    return 0;
}
DWORD WINAPI FunTwo(LPVOID param) {
    while (true)
    {
        Sleep(1000);
        cout << "world! ";
    }
    return 0;
}

//注意创建线程函数的第五个参数的运用。
//输入1和2数字，可以控制线程的启动和终止。
//注意连续输入1和2数字线程的运行情况。
//线程的终止函数。

int main(int argc, char* argv[])
{
    int input = 0;

    //创建线程。这里第四个参数值设为NULL也可以，因为线程函数里没有使用输入参数。
    HANDLE hand1 = CreateThread(NULL, 0, FunOne, (void*)&input, CREATE_SUSPENDED, NULL);
    HANDLE hand2 = CreateThread(NULL, 0, FunTwo, (void*)&input, CREATE_SUSPENDED, NULL);
    while (true) {
        cin >> input;
        if (input == 1)
        {
            //恢复线程
            ResumeThread(hand1);
            ResumeThread(hand2);
        }
        if (input == 2)
        {
            //挂起线程
            SuspendThread(hand1);
            SuspendThread(hand2);
        }
        if (input == 0)
        {
            //终止线程
            TerminateThread(hand1, 1);
            TerminateThread(hand2, 1);
        }
        if (input == 9)
            return 0;
    };

    return 0;

}

三、利用全局变量实现同步

这样做可能会有一个问题,主线程结束时其他线程也就跟着结束了

全局变量
进程中的所有线程均可以访问所有的全局变量，因而全局变量成为Win32多线程通信的最简单方式。
int var; //全局变量
UINT ThreadFunction ( LPVOID pParam {
while (var)
{
…… //线程处理
}
return 0; }
var是一个全局变量，任何线程均可以访问和修改。线程间可以利用此特性达到线程同步的目的。

#include "stdio.h"
#include <windows.h> 
#include <iostream> 
using namespace std;

//使用全局变量同步线程的例子。

//全局变量。
int globalvar = false;

DWORD WINAPI ThreadFunc(LPVOID pParam)
{
    cout << "  ThreadFunc  " << endl;
    Sleep(100);

    //修改全局变量的值。
    globalvar = true;

    return 0;
}
DWORD WINAPI ThreadFunc1(LPVOID pParam)
{
    while (1)
        cout << "  ThreadFunc111  " << endl;
    return 0;
}
DWORD WINAPI ThreadFunc2(LPVOID pParam)
{
    while (1)
        cout << "  ThreadFunc222  " << endl;
    return 0;
}

//这种方式可能存在一些问题。

int main()
{
    HANDLE hthread1 = CreateThread(NULL, 0, ThreadFunc1, NULL, 0, NULL);
    HANDLE hthread2 = CreateThread(NULL, 0, ThreadFunc2, NULL, 0, NULL);
    HANDLE hthread = CreateThread(NULL, 0, ThreadFunc, NULL, 0, NULL);
    if (!hthread)
    {
        cout << "Thread Create Error ! " << endl;
        CloseHandle(hthread);
    }
    bool b =SetThreadPriority(hthread,15);
    cout<<GetThreadPriority(hthread1)<<endl;
    cout<<GetThreadPriority(hthread2)<<endl;
    cout<<GetThreadPriority(hthread)<<endl;

    //循环判断全局变量的值。
    while (!globalvar)
        cout << "Thread while" << endl;

    cout << "Thread exit" << endl;
    return 0;
}

四、利用事件实现同步

事件是WIN32提供的最灵活的线程间同步方式。
事件存在两种状态：
激发状态(signaled or true)
未激发状态(unsignal or false)
事件可分为两类：
手动设置：这种对象只能用程序来手动设置，在需要该事件或者事件发生时，采用SetEvent及ResetEvent来进行设置。
SetEvent只有一个参数，该参数指定了事件对象的句柄值，若事件成功激发，返回TRUE;
ResetEvent函数将事件对象恢复到最初的非激发状态，只有一个参数，成功后返回真
自动恢复：一旦事件发生并被处理后，自动恢复到没有事件状态，不需要再次设置。
CreateEvent(NULL, FALSE, FALSE, NULL);
第一个参数还是安全,默认为NULL,二参代表事件类型,true为手动清除信号,false为自动清除
三参:事件的初始状态四参:事件的名称
setEvent(句柄)
WaitForSingleObject(evRead, INFINITE);等待某个事件
WaitForSingleObject (evFinish, INFINITE)
参数1：等待对象
参数2：等待时间
返回值：WAIT_OBJECT_0（激发）
WAIT_TIMEOUT（超时）
WAIT_FAILED（错误）
WaitForMultipleObjects(2 ,evFin ,TRUE ,INFINITE)
参数1：等待的句柄数
参数2：等待的句柄数组
参数3：确定是否等待所有句柄激发后才返回
参数4：等待时间
返回值： WAIT_OBJECT_I（激发事件在句柄数组中的索引）
例子:有三个线程
主线程、读线程ReadThread、写线程WriteThread
读线程ReadThread必须在写线程WriteThread 的写操作完成之后才能进行读操作
主线程必须在读线程ReadThread 的读操作完成后才结束
定义两个事件对象evRead，evFinish
evRead由写线程WriteThread用于通知读线程ReadThread 进行读操作
evFinish由读线程ReadThread用于通知主线程读操作已经结束

#include "stdio.h"
#include <windows.h> 
#include <iostream> 
using namespace std;

//**使用事件机制同步线程的例子。

//两个事件。
HANDLE evRead, evFin;
HANDLE evWrite;

void ReadThread(LPVOID param)
{
    //等待读事件。
    WaitForSingleObject(evRead, INFINITE);

    cout << "Reading" << endl;
    //ResetEvent(evRead);//evRead为手动恢复类型时打开
    SetEvent(evWrite);
    WaitForSingleObject(evRead, INFINITE);
    cout << "Reading11111" << endl;

    //激活结束事件。
    SetEvent(evFin);
}
void WriteThread(LPVOID param)
{
    cout << "Writing" << endl;

    //激活读事件。
    SetEvent(evRead);

    WaitForSingleObject(evWrite, INFINITE);
    cout << "Writing11111" << endl;
    SetEvent(evRead);
}
int main(int argc, char* argv[])
{
    //创建两个事件，注意事件参数的含义。
    evRead = CreateEvent(NULL, FALSE, FALSE, NULL);
    evFin = CreateEvent(NULL, FALSE, FALSE, NULL);

    evWrite = CreateEvent(NULL, FALSE, FALSE, NULL);
    //evRead = CreateEvent (NULL ,TRUE ,FALSE ,NULL) ;//修改第二个参数为TRUE
    //evFin = CreateEvent (NULL ,TRUE ,FALSE ,NULL) ;//修改第二个参数为TRUE
    //evWrite = CreateEvent (NULL ,TRUE ,FALSE ,NULL) ;//修改第二个参数为TRUE

    _beginthread(ReadThread, 0, NULL);
    _beginthread(WriteThread, 0, NULL);

    //等待结束事件。
    WaitForSingleObject(evFin, INFINITE);

    cout << "The Program is End" << endl;
    return 0;
}

五、临界区

防止多个线程同时执行一个特定代码段的机制
适用于多个线程操作之间没有先后顺序，但要求互斥的同步
多个线程访问同一个临界区的原则：
一次最多只能一个线程停留在临界区内
不能让一个线程无限地停留在临界区内，否则其它线程将不能进入该临界区
定义临界区变量的方法如下：
CRITICAL_SECTION gCriticalSection;
通常情况下，CRITICAL_SECTION结构体应该被定义为全局变量，便于进程中的所有线程可以方便地按照变量名来引用该结构体。
初始化临界区
VOID WINAPI InitializeCriticalSection (
LPCRITICAL_SECTION lpCriticalSection );
删除临界区
VOID WINAPI DeleteCriticalSection (
LPCRITICAL_SECTION lpCriticalSection );
进入临界区
VOID WINAPI EnterCriticalSection (
LPCRITICAL_SECTION lpCriticalSection );
执行该语句时，程序会判断cs对象是否已被锁定，若没锁定则线程进入临界区，并将cs置为锁定状态；否则，线程线程被阻塞以等待cs解锁。
离开临界区
VOID WINAPI LeaveCriticalSection (
　 LPCRITICAL_SECTION lpCriticalSection );
线程执行该语句后，程序自动将cs解锁，并唤醒等待cs解锁的线程
使用临界区编程的一般方法是：
void WriteData()
{
EnterCriticalSection(&gCriticalSection);
//do something
LeaveCriticalSection(&gCriticalSection);
}
例子
假如一个银行系统有两个线程执行取款任务，一个使用存折在柜台取款，一个使用银行卡在ATM取款。若不加控制，很可能账户余额不足两次取款的总额，但还可以把钱取走。

#include "stdio.h"
#include <windows.h> 
#include <iostream> 
#include <process.h>
#include <iostream>
#include <fstream>
using namespace std;

//**使用临界区机制同步线程。

int total = 100;
HANDLE evFin[2];
CRITICAL_SECTION cs;//临界区。

//可以去掉临界区机制，查看是否出现错误。（需要辅助sleep函数）
void WithdrawThread1(LPVOID param)
{
    EnterCriticalSection(&cs);//进入临界区
    if (total - 90 >= 0)
    {//Sleep(100);
        total -= 90;
        cout << "You withdraw 90" << endl;
    }
    else
        cout << "You do not have that much money" << endl;
    LeaveCriticalSection(&cs);//退出临界区
    SetEvent(evFin[0]);
}
void WithdrawThread2(LPVOID param)
{
    EnterCriticalSection(&cs);//进入临界区
    if (total - 20 >= 0)
    {
        total -= 20;
        cout << "You withdraw 20" << endl;
    }
    else
        cout << "You do not have that much money" << endl;
    LeaveCriticalSection(&cs);//退出临界区
    //LeaveCriticalSection(&cs) ;
    SetEvent(evFin[1]);
}
int main(int argc, char* argv[])
{
    evFin[0] = CreateEvent(NULL, FALSE, FALSE, NULL);
    evFin[1] = CreateEvent(NULL, FALSE, FALSE, NULL);

    InitializeCriticalSection(&cs);//初始化临界区。

    _beginthread(WithdrawThread1, 0, NULL);//创建线程顺序影响执行的结果。
    _beginthread(WithdrawThread2, 0, NULL);
    //_beginthread(WithdrawThread1 , 0 , NULL) ;

    int id = WaitForMultipleObjects(2, evFin, TRUE, INFINITE);//等待两个事件都激活。
    cout << "句柄数组中的索引:" << id << endl;

    DeleteCriticalSection(&cs);//删除临界区

    cout << total << endl;
    return 0;
}

六、互斥量

通常用于协调多个线程或进程的活动，通过对资源“锁定”和“取消锁定”，来控制对共享资源的访问。
当一个互斥量被一个线程锁定了，其他试图对其加锁的线程就会被阻塞；当对互斥量加锁的线程解除锁定后，则被阻塞的线程中的一个会得到互斥量。
互斥量的作用是保证每次只能有一个线程获得互斥量
使用CreateMutex函数创建：
HANDLE CreateMutex(
LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCTSTR lpName
);
安全属性是否手动清除(true为手动) 名称
相关的API：
CreateMutex 创建一个互斥对象，返回对象句柄；
OpenMutex 打开并返回一个已存在的互斥对象的句柄，使之后续访问；
ReleaseMutex 释放对互斥对象的占用，使之成为可用；
使用互斥量的一般方法是：
void Writedata()
{
WaitForSingleObject(hMutex,…);
...//do something
ReleaseMutex(hMutex);
}

#include "stdio.h"
#include <windows.h> 
#include <iostream> 
#include <process.h>
#include <iostream>
#include <fstream>
using namespace std;

//**互斥量的使用方法。

#define THREAD_INSTANCE_NUMBER  3

LONG g_fResourceInUse = FALSE;
LONG g_lCounter = 0;

DWORD ThreadProc(void* pData) {

    int ThreadNumberTemp = (*(int*)pData);
    HANDLE hMutex;

    if ((hMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "Mutex.Test")) == NULL) {
        cout << "Open Mutex error!" << endl;
    }

    //cout << "ThreadProc is running hMutexxxxxxx!!"  << ThreadNumberTemp <<endl;
    WaitForSingleObject(hMutex, INFINITE);//获取互斥量。
    cout << "ThreadProc is running!!" << ThreadNumberTemp << endl;
    cout << "ThreadProc gets the mutex-" << ThreadNumberTemp << endl;

    ReleaseMutex(hMutex);//释放互斥量。
    CloseHandle(hMutex);
    return 0;
}

int main(int argc, char* argv[])
{

    int i;
    DWORD ID[THREAD_INSTANCE_NUMBER];
    HANDLE h[THREAD_INSTANCE_NUMBER];
    HANDLE hMutex;
    if ((hMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "Mutex.Test")) == NULL) {
        if ((hMutex = CreateMutex(NULL, FALSE, "Mutex.Test")) == NULL) //注意第二个参数，当前线程是否拥有创建的锁
        {
            cout << "Create Mutex error!" << endl;
            return 0;
        }
    }
    //ReleaseMutex(hMutex);  //CreateMutex函数第二参数为TRUE时打开

    //获取信号量的位置不同，将产生不同的结果。
   //WaitForSingleObject(hMutex,INFINITE);
    for (i = 0; i < THREAD_INSTANCE_NUMBER; i++)
    {
        WaitForSingleObject(hMutex, INFINITE);//获取互斥量。本线程可重复获取，但解锁时需释放相同的次数。
        h[i] = CreateThread(NULL,
            0,
            (LPTHREAD_START_ROUTINE)ThreadProc,
            (void*)&ID[i],
            0,
            &(ID[i]));
        //WaitForSingleObject(hMutex,INFINITE);//演示重复获取互斥量
        if (h[i] == NULL)
            cout << "CreateThread error" << ID[i] << endl;
        else
            cout << "CreateThread: " << ID[i] << endl;
        ReleaseMutex(hMutex);
        //Sleep(1000);
    }
    //ReleaseMutex(hMutex);//ReleaseMutex(hMutex);ReleaseMutex(hMutex);//演示释放重复获取的互斥量

    WaitForMultipleObjects(THREAD_INSTANCE_NUMBER, h, TRUE, INFINITE);
    cout << "Close the Mutex Handle! " << endl;
    CloseHandle(hMutex);

    return 0;
}

七、信号量

信号量是一个核心对象，拥有一个计数器，可用来管理大量有限的系统资源
当计数值大于零时，信号量为有信号状态
当计数值为零时，信号量处于无信号状态
创建信号量
HANDLE CreateSemaphore (PSECURITY_ATTRIBUTE psa,
LONG lInitialCount, LONG lMaximumCount, PCTSTR pszName);
安全属性初始数量最大数量信号量名称
释放信号量
BOOL WINAPI ReleaseSemaphore(HANDLE hSemaphore,
LONG lReleaseCount, //信号量的当前资源数增加lReleaseCount
LPLONG lpPreviousCount);
打开信号量
HANDLE OpenSemaphore (DWORD fdwAccess,
BOOL bInherithandle, PCTSTR pszName );

// exa7.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <windows.h> 
#include <iostream>
using namespace std;

//**使用信号量机制同步线程。

#define THREAD_INSTANCE_NUMBER  3

DWORD foo(void * pData) {

    int ThreadNumberTemp = (*(int*) pData);
    HANDLE hSemaphore;

    if ((hSemaphore = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "Semaphore.Test")) == NULL) {
        cout << "Open Semaphore error!" << endl;
    }

    WaitForSingleObject(hSemaphore,INFINITE);//获取信号量。

    cout << "foo is running!!!"  << ThreadNumberTemp << endl;
    cout << "foo gets the semaphore-" << ThreadNumberTemp<< endl;
    
    ReleaseSemaphore(hSemaphore, 1, NULL);//释放一个单位的信号量

    CloseHandle(hSemaphore);
    return 0;
}

int main(int argc, char* argv[])
{

    int i;
    DWORD ThreadID[THREAD_INSTANCE_NUMBER]; 
    HANDLE hThread[THREAD_INSTANCE_NUMBER];
    HANDLE hSemaphore;

    
    if ((hSemaphore = CreateSemaphore(NULL,1,1, "Semaphore.Test")) == NULL ) {
        cout << "Create Semaphore error!" << endl;
        return 0;
    }   

    //与互斥量一样，这里获取信号量的位置不同，会产生不同的结果。
    for (i=0;i<THREAD_INSTANCE_NUMBER;i++)
    {
        WaitForSingleObject(hSemaphore,INFINITE);//获取信号量。不可重入。
        hThread[i] = CreateThread(NULL, 
                            0,                          
                            (LPTHREAD_START_ROUTINE) foo, 
                            (void *)&ThreadID[i],                    
                            0,                       
                            &(ThreadID[i]));              
        
        if (hThread[i] == NULL)

            cout << "CreateThread error" << ThreadID[i] << endl;
        else
            cout << "CreateThread: " << ThreadID[i] << endl;

        ReleaseSemaphore(hSemaphore, 1, NULL);
    }

    WaitForMultipleObjects(THREAD_INSTANCE_NUMBER,hThread,TRUE,INFINITE);
    cout << "Close the Semaphore Handle! " << endl;
    CloseHandle(hSemaphore);

    return 0;
}

fengruoying93

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
win32API多线程编程

原文1：https://blog.csdn.net/gengshenghong/article/details/6945216原文2：https://www.cnblogs.com/Tony100K/p/11758936.htmlRef:MSDN:http://msdn.microsoft.com/zh-cn/library/y6h8hye8(v=VS.100)一、win32多线...
复制链接

扫一扫