【代码】Visual C++线程同步技术剖析:临界区，事件，信号量，互斥量-白红宇

【代码】Visual C++线程同步技术剖析:临界区，事件，信号量，互斥量

阅读量：2360 次

发布时间：2019-05-10

本文共 9978 字，大约阅读时间需要 33 分钟。

编译程序前设置：Project-->Settings-->Use MFC as a static DLL

第一部分CriticalSection

1.1、临界区结构对象CRITICAL_SECTION

/*
与事件相比，临界区更适合于多个线程操作之间没有先后顺序但要求互斥的同步。
在使用临界区时，一般不允许其运行时间过长，只要进入临界区的线程还没有离开，
其他所有试图进入此临界区的线程都会被挂起而进入到等待状态，并会在一定程度上影响。
程序的运行性能。尤其需要注意的是不要将等待用户输入或是其他一些外界干预的操作包含到临界区。
如果进入了临界区却一直没有释放，同样也会引起其他线程的长时间等待。
换句话说，在执行了EnterCriticalSection（）语句进入临界区后无论发生什么，
必须确保与之匹配的LeaveCriticalSection（）都能够被执行到。可以通过添加结构化异常处理代码来确保 
LeaveCriticalSection（）语句的执行。虽然临界区同步速度很快，但却只能用来同步本进程内的线程，
而不可用来同步多个进程中的线程。
*/
#include   <afxwin.h> /*Project-->Settings-->Use MFC as a static DLL*/ 
// 临界区结构对象 
CRITICAL_SECTION g_cs;
// 共享资源 
char g_cArray[10];
UINT ThreadProc10(LPVOID pParam)
{ 
    // 进入临界区 
    EnterCriticalSection(&g_cs);
    // 对共享资源进行写入操作 
    for (int i = 0; i < 10; i++)
    { 
        g_cArray[i] = 'a';
        Sleep(1);
    }
    // 离开临界区 
    LeaveCriticalSection(&g_cs);
    return 0;
}
UINT ThreadProc11(LPVOID pParam)
{ 
    // 进入临界区 
    EnterCriticalSection(&g_cs);
    // 对共享资源进行写入操作 
    for (int i = 0; i < 10; i++)
    { 
        g_cArray[10 - i - 1] = 'b';
        Sleep(1);
    }
    // 离开临界区 
    LeaveCriticalSection(&g_cs);
    return 0;
}
int main()
{ 
    //初始化临界区 
    InitializeCriticalSection(&g_cs);
    //启动线程 
    AfxBeginThread(ThreadProc10, NULL);
    AfxBeginThread(ThreadProc11, NULL);
    //等待计算完毕 
    Sleep(300);
    //报告计算结果 
    CString sResult = CString(g_cArray);
    AfxMessageBox(sResult);
    return 0;
}

1.2、MFC临界区CCriticalSection类

/*
MFC为临界区提供有一个CCriticalSection类，使用该类进行线程同步处理是非常简单的，
只需在线程函数中用CCriticalSection类成员函数Lock（）和UnLock（）标定出被保护代码片段即可。
对于上述代码，可通过 CCriticalSection类将其改写如下：
*/
#include   <afxwin.h> /*Project-->Settings-->Use MFC as a static DLL*/ 
#include   <afxmt.h> /*用CSyncObject，CMutex，CSemaphore，CEvent，CCriticalSection这些类需要包含头文件 */ 
// MFC临界区类对象 
CCriticalSection g_clsCriticalSection;
// 共享资源 
char g_cArray[10];
UINT ThreadProc10(LPVOID pParam)
{ 
    // 进入临界区 
    g_clsCriticalSection.Lock();
    // 对共享资源进行写入操作 
    for (int i = 0; i < 10; i++)
    { 
        g_cArray[i] = 'a';
        Sleep(1);
    }
    // 离开临界区 
    g_clsCriticalSection.Unlock();
    return 0;
}
UINT ThreadProc11(LPVOID pParam)
{ 
    // 进入临界区 
    g_clsCriticalSection.Lock();
    // 对共享资源进行写入操作 
    for (int i = 0; i < 10; i++)
    { 
        g_cArray[10 - i - 1] = 'b';
        Sleep(1);
    }
    // 离开临界区 
    g_clsCriticalSection.Unlock();
    return 0;
}
int main()
{ 
    //启动线程 
    AfxBeginThread(ThreadProc10, NULL);
    AfxBeginThread(ThreadProc11, NULL);
    //等待计算完毕 
    Sleep(300);
    //报告计算结果 
    CString sResult = CString(g_cArray);
    AfxMessageBox(sResult);
    return 0;
}

第二部分Event

2.1、等待单个事件

/*
使用临界区只能同步同一进程中的线程，而使用事件内核对象则可以对进程外的线程进行同步，
其前提是得到对此事件对象的访问权。可以通过OpenEvent（）函数获取得到，其函数原型为：
  HANDLE OpenEvent(
  　DWORD dwDesiredAccess, // 访问标志
  　BOOL bInheritHandle, // 继承标志
  　LPCTSTR lpName // 指向事件对象名的指针
);
*/
#include <afxwin.h> 
#include <afxmt.h> 
// 事件句柄 
HANDLE hEvent = NULL;
// 共享资源 
char g_cArray[10];
UINT ThreadProc12(LPVOID pParam)
{ 
    // 等待事件置位 
    WaitForSingleObject(hEvent, INFINITE);
    // 对共享资源进行写入操作 
    for (int i = 0; i < 10; i++)
    { 
        g_cArray[i] = 'a';
        Sleep(1);
    }
    // 处理完成后即将事件对象置位 
    SetEvent(hEvent);
    return 0;
}
UINT ThreadProc13(LPVOID pParam)
{ 
    // 等待事件置位 
    WaitForSingleObject(hEvent, INFINITE);
    // 对共享资源进行写入操作 
    for (int i = 0; i < 10; i++)
    { 
        g_cArray[10 - i - 1] = 'b';
        Sleep(1);
    }
    // 处理完成后即将事件对象置位 
    SetEvent(hEvent);
    return 0;
}
int main()
{ 
    // 创建事件 
    hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    // 事件置位 
    SetEvent(hEvent);
    // 启动线程 
    AfxBeginThread(ThreadProc12, NULL);
    AfxBeginThread(ThreadProc13, NULL);
    // 等待计算完毕 
    Sleep(300);
    // 报告计算结果 
    CString sResult = CString(g_cArray);
    AfxMessageBox(sResult);
    return 0;
}

2.2、等待多个事件

#include <afxwin.h> 
#include <afxmt.h> 
// 存放事件句柄的数组 
HANDLE hEvents[2];
UINT ThreadProc14(LPVOID pParam)
{ 
    // 等待开启事件 
    DWORD dwRet1 = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE);
    // 如果开启事件到达则线程开始执行任务 
    if (dwRet1 == WAIT_OBJECT_0)
    { 
        AfxMessageBox("线程开始工作!");
        while (true)
        { 
            for (int i = 0; i < 10000; i++);
            // 在任务处理过程中等待结束事件 
            DWORD dwRet2 = WaitForMultipleObjects(2, hEvents, FALSE, 0);
            // 如果结束事件置位则立即终止任务的执行 
            if (dwRet2 == WAIT_OBJECT_0 + 1)
                break;
        }
    }
    AfxMessageBox("线程退出!");
    return 0;
}
void StartEvent()
{ 
    // 创建线程 
    for (int i = 0; i < 2; i++)
        hEvents[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
    // 开启线程 
    AfxBeginThread(ThreadProc14, NULL);
    // 设置事件0(开启事件) 
    SetEvent(hEvents[0]);
}
void Endevent()
{ 
    // 设置事件1(结束事件) 
    SetEvent(hEvents[1]);
}
int main()
{ 
    StartEvent();
    Sleep(1000);
    Endevent();
    Sleep(1000);
    return 0;
}

2.3、CEvent

MFC为事件相关处理也提供了一个CEvent类，共包含有除构造函数外的4个成员函数PulseEvent（）、 ResetEvent（）、SetEvent（）和UnLock（）。在功能上分别相当与Win32 API的PulseEvent（）、ResetEvent（）、SetEvent（）和CloseHandle（）等函数。而构造函数则履行了原 CreateEvent（）函数创建事件对象的职责，其函数原型为：

CEvent(BOOL bInitiallyOwn = FALSE, BOOL bManualReset = FALSE, LPCTSTR lpszName = NULL, LPSECURITY_ATTRIBUTES lpsaAttribute = NULL );

#include <afxwin.h> 
#include <afxmt.h> 
// 共享资源 
char g_cArray[10];
// MFC事件类对象 
CEvent g_clsEvent;
UINT ThreadProc22(LPVOID pParam)
{ 
    // 对共享资源进行写入操作 
    for (int i = 0; i < 10; i++)
    { 
        g_cArray[i] = 'a';
        Sleep(1);
    }
    // 事件置位 
    g_clsEvent.SetEvent();
    return 0;
}
UINT ThreadProc23(LPVOID pParam)
{ 
    // 等待事件 
    g_clsEvent.Lock();
    // 对共享资源进行写入操作 
    for (int i = 0; i < 10; i++)
    { 
        g_cArray[10 - i - 1] = 'b';
        Sleep(1);
    }
    return 0;
}
int main()
{ 
    // 启动线程 
    AfxBeginThread(ThreadProc22, NULL);
    AfxBeginThread(ThreadProc23, NULL);
    // 等待计算完毕 
    Sleep(300);
    // 报告计算结果 
    CString sResult = CString(g_cArray);
    AfxMessageBox(sResult);
    return 0;
}

第三部分Semaphore

3.1、信号量（Semaphore）内核对象对线程的同步方式与前面几种方法不同，它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。

#include <afxwin.h> 
// 信号量对象句柄 
HANDLE hSemaphore;
UINT ThreadProc15(LPVOID pParam)
{ 
    // 试图进入信号量关口 
    WaitForSingleObject(hSemaphore, INFINITE);
    // 线程任务处理 
    AfxMessageBox("线程一正在执行!");
    // 释放信号量计数 
    ReleaseSemaphore(hSemaphore, 1, NULL);
    return 0;
}
UINT ThreadProc16(LPVOID pParam)
{ 
    // 试图进入信号量关口 
    WaitForSingleObject(hSemaphore, INFINITE);
    // 线程任务处理 
    AfxMessageBox("线程二正在执行!");
    // 释放信号量计数 
    ReleaseSemaphore(hSemaphore, 1, NULL);
    return 0;
}
UINT ThreadProc17(LPVOID pParam)
{ 
    // 试图进入信号量关口 
    WaitForSingleObject(hSemaphore, INFINITE);
    // 线程任务处理 
    AfxMessageBox("线程三正在执行!");
    // 释放信号量计数 
    ReleaseSemaphore(hSemaphore, 1, NULL);
    return 0;
}
int main()
{ 
    // 创建信号量对象 
    hSemaphore = CreateSemaphore(NULL, 2, 2, NULL);
    // 开启线程 
    AfxBeginThread(ThreadProc15, NULL);
    Sleep(1000);
    AfxBeginThread(ThreadProc16, NULL);
    Sleep(2000);
    AfxBeginThread(ThreadProc17, NULL);
    Sleep(3000);
    return 0;
}

3.2、CSemaphore

#include <afxwin.h> 
#include <afxmt.h> 
// MFC信号量类对象 
CSemaphore g_clsSemaphore(2, 2);
UINT ThreadProc24(LPVOID pParam)
{ 
    // 试图进入信号量关口 
    g_clsSemaphore.Lock();
    // 线程任务处理 
    AfxMessageBox("线程一正在执行!");
    // 释放信号量计数 
    g_clsSemaphore.Unlock();
    return 0;
}
UINT ThreadProc25(LPVOID pParam)
{ 
    // 试图进入信号量关口 
    g_clsSemaphore.Lock();
    // 线程任务处理 
    AfxMessageBox("线程二正在执行!");
    // 释放信号量计数 
    g_clsSemaphore.Unlock();
    return 0;
}
UINT ThreadProc26(LPVOID pParam)
{ 
    // 试图进入信号量关口 
    g_clsSemaphore.Lock();
    // 线程任务处理 
    AfxMessageBox("线程三正在执行!");
    // 释放信号量计数 
    g_clsSemaphore.Unlock();
    return 0;
}
int main()
{ 
    // 开启线程 
    AfxBeginThread(ThreadProc24, NULL);
    Sleep(1000);
    AfxBeginThread(ThreadProc25, NULL);
    Sleep(2000);
    AfxBeginThread(ThreadProc26, NULL);
    Sleep(3000);
    return 0;
}

第四部分 Mutex

4.1、Mutex

#include <afxwin.h> 
// 互斥对象 
HANDLE hMutex = NULL;
char g_cArray[10];
UINT ThreadProc18(LPVOID pParam)
{ 
    // 等待互斥对象通知 
    WaitForSingleObject(hMutex, INFINITE);
    // 对共享资源进行写入操作 
    for (int i = 0; i < 10; i++)
    { 
        g_cArray[i] = 'a';
        Sleep(1);
    }
    // 释放互斥对象 
    ReleaseMutex(hMutex);
    return 0;
}
UINT ThreadProc19(LPVOID pParam)
{ 
    // 等待互斥对象通知 
    WaitForSingleObject(hMutex, INFINITE);
    // 对共享资源进行写入操作 
    for (int i = 0; i < 10; i++)
    { 
        g_cArray[10 - i - 1] = 'b';
        Sleep(1);
    }
    // 释放互斥对象 
    ReleaseMutex(hMutex);
    return 0;
}
int main()
{ 
    // 创建互斥对象 
    hMutex = CreateMutex(NULL, FALSE, NULL);
    // 启动线程 
    AfxBeginThread(ThreadProc18, NULL);
    AfxBeginThread(ThreadProc19, NULL);
    // 等待计算完毕 
    Sleep(300);
    // 报告计算结果 
    CString sResult = CString(g_cArray);
    AfxMessageBox(sResult);
    return 0;
} 

4.2、CMutex

#include <afxwin.h> 
#include <afxmt.h> 
char g_cArray[10];
// MFC互斥类对象 
CMutex g_clsMutex(FALSE, NULL);
UINT ThreadProc27(LPVOID pParam)
{ 
    // 等待互斥对象通知 
    g_clsMutex.Lock();
    // 对共享资源进行写入操作 
    for (int i = 0; i < 10; i++)
    { 
        g_cArray[i] = 'a';
        Sleep(1);
    }
    // 释放互斥对象 
    g_clsMutex.Unlock();
    return 0;
}
UINT ThreadProc28(LPVOID pParam)
{ 
    // 等待互斥对象通知 
    g_clsMutex.Lock();
    // 对共享资源进行写入操作 
    for (int i = 0; i < 10; i++)
    { 
        g_cArray[10 - i - 1] = 'b';
        Sleep(1);
    }
    // 释放互斥对象 
    g_clsMutex.Unlock();
    return 0;
}
int main()
{ 
    // 启动线程 
    AfxBeginThread(ThreadProc27, NULL);
    AfxBeginThread(ThreadProc28, NULL);
    // 等待计算完毕 
    Sleep(300);
    // 报告计算结果 
    CString sResult = CString(g_cArray);
    AfxMessageBox(sResult);
    return 0;
}

采用线程的好处: 为什么使用多个线程而不使用多个进程?

一个进程可以产生多个线程，这些线程都共享该进程的地址空间，它们可以并行、异步地执行。

采用线程最主要的好处是：使同一个程序能有几个并行执行的路径，提高了执行速度；线程需要的系统开销比进程要小。应该说明的是，在 Windows95中，“多任务”是基于线程而不是基于进程。

为什么使用多个线程而不使用多个进程?

最重要的答案便是:线程价廉.线程启动比较快,退出比较快,对系统资源的冲击也比较小.而且线程彼此分享了大部分核心对象(如file handles)的拥有权.

多任务执行

多任务执行是指在同一台计算机系统的同一时刻运行多个程序。由于允许活动任务和后台任务同时运行，所以可以做到有一个任务在后台执行时，前台又能干另一件事。比如说，我们可以一边用图文处理程序编辑一个文件，一边让打印程序完成打印工作。这就极大地提高了工作效率，因为大多数用户都确实需要同时对几个不同的应用程序进行工作。

线程分类

内核线程：由操作系统内核创建和撤销。内核维护进程及线程的上下文信息以及线程切换。一个内核线程由于I/O操作而阻塞，不会影响其它线程的运行。Windows NT和2000/XP支持内核线程。

用户线程：由应用进程利用线程库创建和管理，不以来于操作系统核心。不需要用户态/核心态切换，速度快。操作系统内核不知道多线程的存在，因此一个线程阻塞将使得整个进程（包括它的所有线程）阻塞。由于这里的处理器时间片分配是以进程为基本单位，所以每个线程执行的时间相对减少。

轻量级进程：一个进程可以有多个LWP，每个LWP由一个单独的内核线程来支持。融合了前面两者的优点，是一个折中方案。

2 线程间通信 VS 进程间通信

关于线程间通信，涉及到同一进程内的所有线程通信和不同进程的线程间通信；因为同一进程中的所有线程均可以访问所有的全局变量，因而全局变量成为同一进程间多线程通信的最简单方式。但如何访问全局变量是多线程程序必须考虑的一个问题。而对于不同进程间线程通信问题实质上就是进程间通信问题。
因此本文将线程间通信特指同一进程中的所有线程通信问题，实质就是解决线程间的竞争问题。而进程间通信指在操作系统书中介绍的传统意义上的进程通信问题。

2.1 线程间通信

多线程程序的核心问题；竞争对(共享)资源的竞争关系.解决这种竞争关系的方法就是线程间通信问题，包括互斥和同步。

线程程同步：是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。

线程互斥:是指对于共享的操作系统资源（指的是广义的"资源"，而不是Windows的.res文件，譬如全局变量就是一种共享资源），在各线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。(原子操作，互锁访问)

线程互斥是一种特殊的线程同步。

实际上，互斥和同步对应着线程间通信发生的两种情况：

（1）当有多个线程访问共享资源而不使资源被破坏时；

（2）当一个线程需要将某个任务已经完成的情况通知另外一个或多个线程时。

在WIN32中，同步机制主要有以下几种：

（1）事件(Event);(内)核心对象，多用于overlapped。适用于不同进程的线程。

（2）信号量(semaphore)；核心对象，无拥有者。适用于不同进程的线程。

（3）互斥量(mutex)；内核对象(内)核心对象，排他性对象，甚至适用于不同进程的线程。

（4）临界区(Critical section)。局部对象，不是(内)核心对象，仅适用于同一个进程的不同线程。

2.2 进程间通信

几个系统中近程通信的方法：

unix：管道，消息队列，信号(signal)，信号量(灯)，共享存储，socket。