C++ 多线程同步之Mutex(互斥量)

转载

mob604756e6f1ac 2021-09-22 15:27:00

一、互斥量Mutex同步多线程

1、Win32平台

相关函数和头文件

 1 #include <windows.h>
 2 HANDLE CreateMutex(
 3 LPSECURITY_ATTRIBUTESlpMutexAttributes, // 指向安全属性的指针
 4 BOOLbInitialOwner, // 初始化互斥对象的所有者
 5 LPCTSTRlpName // 指向互斥对象名的指针
 6 );
 7 
 8 DWORD WINAPI WaitForSingleObject(
 9 __in HANDLE hHandle,//互斥量对象句柄
10 __in DWORD dwMilliseconds//等待时间
11 );
12 
13 BOOL WINAPI ReleaseMutex(HANDLE hMutex);
14 返回值:BOOL，TRUE表示成功，FALSE表示失败。
15 参数表:hMutex：HANDLE，制定一个互斥体的句柄。
16 
17 BOOL CloseHandle(HANDLE hObject);
18 参数: hObject 代表一个已打开对象handle。
19 返回值:
20 TRUE：执行成功；
21 FALSE：执行失败，可以调用GetLastError()获知失败原因。

源码：
从本篇开始，我对代码会进行一些封装，使之更贴近实际使用的情况。

 1 /***MyMutex.h头文件***/
 2 
 3 #ifndef __MY_MUTEX_H
 4 #define __MY_MUTEX_H
 5 #include <windows.h>
 6 
 7 class CMyMutex
 8 {
 9 public:
10     CMyMutex();
11 
12     virtual ~CMyMutex();
13 
14     void Lock();
15 
16     void UnLock();
17 
18 private:
19     HANDLE m_hMutex;
20 };
21 
22 class CAutoLock
23 {
24 public:
25     CAutoLock(CMyMutex* pMutex);
26 
27     virtual ~CAutoLock();
28 
29 private:
30     CMyMutex*           m_pMutex;
31 };
32 
33 #endif;

 1 /***MyMutex.cpp文件***/
 2 
 3 #include <iostream>
 4 #include <windows.h>
 5 #include "MyMutex.h"
 6 
 7 using namespace std;
 8 
 9 CMyMutex::CMyMutex()
10 {
11     m_hMutex = CreateMutex(NULL               /*默认安全属性*/
12                         , false               /*创建线程不拥有该信号量*/
13                         , NULL                /*锁名称*/
14                         );
15 }
16 
17 CMyMutex::~CMyMutex()
18 {
19     if(NULL != m_hMutex)
20     {
21         CloseHandle(m_hMutex);
22         cout<<"m_hMutex被关闭"<<endl;
23     }
24 }
25 
26 void CMyMutex::Lock()
27 {
28     if(NULL == m_hMutex)
29     {
30         cout<<"m_hMutex为空"<<endl;
31         return;
32     }
33     DWORD dRes = -1;
34     dRes = WaitForSingleObject(m_hMutex, INFINITE);
35     if(WAIT_OBJECT_0  == dRes)
36     {
37 //      cout<<"上锁成功!"<<endl;
38     }
39     else if(WAIT_ABANDONED == dRes)
40     {
41         cout<<"发生锁死现象"<<endl;
42     }
43     else if(WAIT_TIMEOUT == dRes)
44     {
45         cout<<"等待超时"<<endl;
46     }
47     else if(WAIT_FAILED == dRes)
48     {
49         cout<<"发生错误"<<endl;
50     }
51     else
52     {
53         cout<<"上锁失败!"<<endl;
54     }
55 
56 }
57 
58 void CMyMutex::UnLock()
59 {
60     ReleaseMutex(m_hMutex);
61 }
62 
63 //****************************CAutoLock*****************************************
64 CAutoLock::CAutoLock(CMyMutex* pMutex)
65 {
66     m_pMutex = pMutex;
67     m_pMutex->Lock();
68 }
69 
70 CAutoLock::~CAutoLock()
71 {
72     m_pMutex->UnLock();
73 }

 1 /***main.cpp文件***/
 2 
 3 #include <iostream>
 4 #include <windows.h>
 5 #include "MySemaphore.h"
 6 #include "MyMutex.h"
 7 using namespace std;
 8 
 9 CMyMutex        MyMutex;/*声明一个全局的互斥量对象（自己封装的）*/
10 
11 DWORD WINAPI Fun(LPVOID lpParamter)
12 {
13     string strPrint((const char*)lpParamter);
14     int iRunTime = 0;
15     //执行100次跳出
16     while(++iRunTime<100)
17     {
18         /*利用CMyMutex的构造函数和析构函数分别取创建和关闭互斥量
19           利用CAutoLock的构造和析构函数去WaitForSingleObject和ReleaseMutex互斥量
20         */
21         CAutoLock cLock(&MyMutex);
22         cout <<"["<< iRunTime <<"]:"<< strPrint.c_str()<<endl;
23         //线程函数阻塞，交出CPU使用权限
24         Sleep(10);
25     }
26     return 0;
27 }
28 
29 int main()
30 {
31     //创建子线程
32     string str1 = "A";
33     string str2 = "B";
34     string str3 = "C";
35     string str4 = "D";
36     string str5 = "E";
37 
38     HANDLE hThread1 = CreateThread(NULL, 0, Fun, (void*)str1.c_str(), 0, NULL);
39     HANDLE hThread2 = CreateThread(NULL, 0, Fun, (void*)str2.c_str(), 0, NULL);
40     HANDLE hThread3 = CreateThread(NULL, 0, Fun, (void*)str3.c_str(), 0, NULL);
41     HANDLE hThread4 = CreateThread(NULL, 0, Fun, (void*)str4.c_str(), 0, NULL);
42     HANDLE hThread5 = CreateThread(NULL, 0, Fun, (void*)str5.c_str(), 0, NULL);
43 
44     //关闭线程
45     CloseHandle(hThread1);
46     CloseHandle(hThread2);
47     CloseHandle(hThread3);
48     CloseHandle(hThread4);
49     CloseHandle(hThread5);
50 
51     getchar();
52 //  system("pause");
53     return 0;
54 }

C++ 多线程同步之Mutex(互斥量)_初始化

运行结果：

五个线程分别打印字符串A到E，各执行99次，没有出现打印混乱（对屏幕资源进行争夺）的情况。

另外有兴趣的读者可以把代码敲一遍，每个线程打印9次，然后把CAutoLock的析构函数内的 m_pMutex->UnLock();注释起来会出现什么情况？可以思考一下。

C++ 多线程同步之Mutex(互斥量)_互斥量_02

运行结果：

出现的现象是：每个线程打印了9次就出现了“发生死锁现象”，而且打印A的线程居然可以不停的对m_pMutex->Lock();这是为什么呢？
WAIT_ABANDONED 0x00000080：当hHandle为mutex时，如果拥有mutex的线程在结束时没有释放核心对象会引发此返回值。这就是为什么会打印“发生死锁现象”，可能这里的提示写的不是很恰当。
另外可以重复执行m_pMutex->Lock()；是因为打印A线程从最开始已经WaitForSingleObject到该互斥量，并且处于有信号状态，因此该线程可以一直打印，打印9次之后，线程已经关闭（实际上线程在打印完9次之前已经被CloseHandle（）了），因此才会出现返回WAIT_ABANDONED 。
在这里为什么打印D线程又能WaitForSingleObject，使互斥量变为有信号状态，那可能就需要知道系统会对未释放核心对象互斥量进行什么处理。从执行结果看，系统又把它变为有信号状态，让其他线程可用了。

2、Linux平台

相关头文件和API

 1 #include<pthread.h>
 2 #include<errno.h>
 3 //初始化信号量接口，如果使用默认的属性初始化互斥量， 只需把attr设为NULL.
 4 int pthread_mutex_init（pthread_mutex_t *restrict mutex， const pthread_mutexattr_t *restric attr）；
 5 //销毁信号量对象接口
 6 int pthread_mutex_destroy（pthread_mutex_t *mutex）；
 7 //互斥量加锁接口--阻塞式
 8 //说明：对共享资源的访问， 要对互斥量进行加锁， 如果互斥量已经上了锁， 调用线程会阻塞， 直到互斥量被解锁。在完成了对共享资源的访问后， 要对互斥量进行解锁。
 9 int pthread_mutex_lock（pthread_mutex_t *mutex）；
10 
11 //互斥量加锁接口--非阻塞式
12 //说明: 这个函数是非阻塞调用模式， 也就是说， 如果互斥量没被锁住， trylock函数将把互斥量加锁， 并获得对共享资源的访问权限； 如果互斥量被锁住了， trylock函数将不会阻塞等待而直接返回EBUSY，表示共享资源处于忙状态。
13 int pthread_mutex_trylock（pthread_mutex_t *mutex）；
14 //互斥量解锁接口
15 int pthread_mutex_unlock（pthread_mutex_t *mutex）；
16 
17 //上述所有返回值： 成功则返回0， 出错则返回错误编号。

初始化：
在Linux下，线程的互斥量数据类型是pthread_mutex_t. 在使用前，要对它进行初始化：
对于静态分配的互斥量，可以把它设置为PTHREAD_MUTEX_INITIALIZER，或者调用pthread_mutex_init;
对于动态分配的互斥量，在申请内存（malloc）之后，通过pthread_mutex_init进行初始化，并且在释放内存（free）前需要调用pthread_mutex_destroy;

死锁：
死锁主要发生在有多个依赖锁存在时，会在一个线程试图以与另一个线程相反顺序锁住互斥量时发生。如何避免死锁是使用互斥量应该格外注意的东西。

总体来讲，有几个不成文的基本原则：

对共享资源操作前一定要获得锁。
完成操作以后一定要释放锁。
尽量短时间地占用锁。
如果有多锁，如获得顺序是ABC连环扣，释放顺序也应该是ABC。
线程错误返回时应该释放它所获得的锁。
各种Mutex的区别：

C++ 多线程同步之Mutex(互斥量)_死锁_03

代码：

 1 /********************************Copyright Qinlong*****************************
 2 ** File   Name:  Mutex.cpp 
 3 ** Create Date:  2016.11.15
 4 ** Modify Time:  2016.11.16
 5 ** Function:     mutex synchornization
 6 ** Author:       qin long
 7 ** Modifier:     **
 8 ** Version:      1.0
 9 *******************************************************************************/
10 
11 #include <iostream>
12 #include <pthread.h>
13 #include <errno.h>
14 using namespace std;
15 
16 //普通锁
17 static pthread_mutex_t g_mutex=PTHREAD_MUTEX_INITIALIZER;
18 //循环执行次数
19 static const int g_iRunTime = 100;
20 
21 void* Fun(void* ptr)
22 {
23    int iRunTime = 0;
24    while(++iRunTime< g_iRunTime)
25    {
26       pthread_mutex_lock(&g_mutex);
27       cout << iRunTime << ": Fun() is running!" << endl;
28 //    若下面一行代码不注释，则主函数输出会出现打印"main trylock failed!"，
29 //    原因就在于g_mutex锁被本线程函数长期占用的结果.
30 //    usleep(200);  
31       pthread_mutex_unlock(&g_mutex);
32       usleep(100000);
33     }
34 }
35 
36 
37 int main()
38 {
39    pthread_t hHandle;
40    int iRet = pthread_create(&hHandle, NULL, Fun, NULL);    //create a thread;
41    if(0 != iRet)
42    {
43        cout << "Create thread failed!" << endl;
44    }
45    sleep(1); 
46    int iRunTime = 0;
47    while(++iRunTime<g_iRunTime)
48    {
49         //这里仅仅是为了测试pthread_mutex_trylock的用法
50       if(EBUSY==pthread_mutex_trylock(&g_mutex))
51       {
52            cout<< "main trylock failed!"<<endl;
53            --iRunTime;
54       }
55       else
56       {
57            cout <<iRunTime<< ": main is running!" << endl;
58            pthread_mutex_unlock(&g_mutex);
59            usleep(100000);
60       }
61    }
62    pthread_join(hHandle, NULL);
63    return 0;
64 }

运行结果：
注释掉Fun中uSleep(200);的结果如下图所示，

C++ 多线程同步之Mutex(互斥量)_互斥量_04

未注释掉Fun中uSleep(200);的结果如下图所示，

C++ 多线程同步之Mutex(互斥量)_死锁_05

这里运行结果出现了main trylock failed!原因是由于Fun函数在打印输出完毕后使用uSleep（200）“长时间占用”锁导致的，从使用pthread_mutex_trylock我们可以看到主函数在经过多次尝试进行加锁都失败了。因此我们的设计原则应该就是尽可能短时间去占用锁，才能提高多线程之间的运行以及同步效率。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。