windows线程同步

一、线程的基本概念。

基本概念：线程，即轻量级进程（LWP:LightWeight Process），是程序执行流的最小单元。一个标准的线程由线程ID、当前指令指针（PC），寄存器集合和堆栈组成。线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程不拥有系统资源，仅拥有少量运行必须的资源。

二、线程的基本状态。

基本状态：就绪、阻塞和运行三种基本状态。

就绪状态，指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；

运行状态，指线程占有处理机正在运行；

阻塞状态，指线程在等待一个事件（如信号量），逻辑上不可执行。

三、进程和线程的关系。

一个程序至少有一个进程,一个进程至少有一个线程.

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

线程同步的四种方式：

1、 临界区（CCriticalSection）： 当多个线程访问一个独占性共享资源时，可以使用临界区对象。拥有临界区的线程可以访问被保护起来的资源或代码段，其他线程若想访问，则被挂起，直到拥有临界区的线程放弃临界区为止。（用户态线程同步：速度快，兼容性差）

（内核态）

2、 事件（CEvent） 事件机制：则允许一个线程在处理完一个任务后，主动唤醒另外一个线程执行任务。每个Cevent对象可以有两种状态：有信号状态和无信号状态。Cevent类对象有两种类型：人工事件和自动事件。 自动事件对象，在被至少一个线程释放后自动返回到无信号状态； 人工事件对象，获得信号后，释放可利用线程，但直到调用成员函数ReSet()才将其设置为无信号状态。在创建Cevent对象时，默认创建的是自动事件。

3、 互斥量（CMutex）： 互斥对象和临界区对象非常相似，只是其允许在进程间使用，而临界区只限制与同一进程的各个线程之间使用， 但是更节省资源，更有效率。

4、 信号量（CSemphore）： 当需要一个计数器来限制可以使用某共享资源的线程数目时，可以使用“信号量”对象。CSemaphore类对象保存了对当前访问某一个指定资源的线程的计数值，该计数值是当前还可以使用该资源的线程数目。如果这个计数达到了零，则所有对这个CSemaphore类对象所控制的资源的访问尝试都被放入到一个队列中等待，直到超时或计数值不为零为止。

（1）、创建一个线程

CreateThread (
    LPSECURITY_ATTRIBUTES  lpThreadAttributes,
    SIZE_T                    dwStackSize,
    LPTHREAD_START_ROUTINE lpStartAddress,
    LPVOID                 lpParameter,
    DWORD                  dwCreationFlags,
    LPDWPRD                lpThreadId
);

----------------------------------------------------------------------------------
// 互斥量、 (同一时间只获得一个线程)
创建互斥量对象：

HANDLE WINAPI CteateMutex(
    LPSECURITY_ATTRIBUTES lpMutexAttributes, // 安全特征
    BOOL                  bInitialOwner,     // 所有权
    LPCWSTR               szName             // 互斥量名称
);

打开一个现有的互斥量：

HANDLE WINAPI OpenMutex(
    DWORD dwDesiredAccess,
    BOOL  bInheritHandle,
    LPCTSTR szName
);

释放互斥量：

BOOL WINAPI ReleaseMutex(
    HANDLE hMutex
);

----------------------------------------------------------------------------------
// 信号量、 (同一时间允许一定数量的线程通过) 
创建信号量对象：

HANDLE WINAPI CreateSemaphore(
    LPSECURITY_ATTRIBUTES lpSemaphpreAttributes,
    LONG                  lInitialCount,         // 设置初始数目以确定信号量的初始触发状态
    LONG                  lMaxinumCount,         // 可同时持有信号量所有权的最多线程对象数目
    LPCWSTR               lpName
);

打开一个信号量对象：

HANDLE WINAPI OpenSemaphore(
        DWORD dwDesiredAccess,
        BOOL bInheritHandle,
        LPCSTR lpName
    );

释放信号量对象：

BOOL WINAPI ReleaseSemaphore(
        HANDLE hSemaphore,
        LONG lReleaseCount,
        LPLONG lpPreviousCount
    );

// 事件、  (播报任何线程都能接收到的公共信号)
创建事件对象：

HANDLE WINAPI CreateEvent(
        LPSECURITY_ATTRIBUTES lpEventAttributes,
        BOOL bManualReset,
        BOOL bInitialState,                // 事件初始状态
        LPCSTR lpName                      // 事件名
    );

打开事件对象：

HANDLE WINAPI OpenEvent(
        DWORD dwDesiredAccess,
        BOOL bInheritHandle,
        LPCSTR lpName
    );

设置事件对象：

BOOL WINAPI SetEvent(
    __in HANDLE hEvent
    );

重置事件对象：

BOOL WINAPI ResetEvent(
    __in HANDLE hEvent
    );

// 脉冲一个事件对象：

BOOL WINAPI PulseEvent(
    __in HANDLE hEvent
    );

-----------------------------------------------------------------------------------
// 临界区、 (智能在一个进程中使用) 
声明临界区对象：

CRITICAL_SECTION m_CritSec;
// 初始化临界区对象
VOID WINAPI InitializeCriticalSection(
        LPCRITICAL_SECTION lpCriticalSection
    );

// 线程进入临界区：

VOID WINAPI EnterCriticalSection(
        LPCRITICAL_SECTION lpCriticalSection
    );
BOOL WINAPI TryEnterCriticalSection(
    __inout LPCRITICAL_SECTION lpCriticalSection
    );

// 线程离开临界区：

VOID WINAPI LeaveCriticalSection(
        LPCRITICAL_SECTION lpCriticalSection
    );

// 释放临界区资源：

VOID WINAPI DeleteCriticalSection(
      LPCRITICAL_SECTION lpCriticalSection
    );

---------------------------------------------------------------------------
// Instance：实例

int i = 0;
HANDLE hMutex;      // 互斥量对象

HANDLE hSemaphore;  // 信号量句柄

HANDLE hEvent;      // 事件句柄

CRITICAL_SECTION Critical;      //定义临界区句柄

DWORD WINAPI ThreadPrco1(LPVOID)
{
    while (i < 100)
    {
        EnterCriticalSection(&Critical);  // 进入临界区
        //WaitForSingleObject(/*hMutex*/ /*hSemaphore*/ hEvent, INFINITE); // 等待
        
        cout<<"ThreadPrco1  "<<i<<endl;
        ++i;
        Sleep(10);
        // ReleaseMutex(hMutex);      // 释放互斥量    
        // ReleaseSemaphore(hSemaphore, 1, 0);  // 释放信号量
        // SetEvent(hEvent);          // 设置事件
        LeaveCriticalSection(&Critical);   // 离开临界区
    }
    return 0L;
}

DWORD WINAPI ThreadPrco2(LPVOID)
{
    while (i < 100)
    {
        EnterCriticalSection(&Critical);
        WaitForSingleObject(/*hMutex*/ /*hSemaphore*/ hEvent, INFINITE);
        
        cout<<"ThreadPrco2  "<<i<<endl;
        ++i;
        Sleep(10);
        // ReleaseMutex(hMutex);
        // ReleaseSemaphore(hSemaphore, 1, 0);
        // SetEvent(hEvent);
        LeaveCriticalSection(&Critical);
    }
    return 0L;
}

int main(int argc, _TCHAR* argv[])
{
    // hMutex = CreateMutex(NULL, FALSE, L"mutex");    // 创建互斥量

    // hSemaphore = CreateSemaphore(NULL, 1, 100, L"sema");  // 创建信号量

    // hEvent = CreateEvent(NULL, FALSE, TRUE, L"event");    // 创建事件

    InitializeCriticalSection(&Critical);   // 初始化临界区对象

    CreateThread(NULL, 0, ThreadPrco1, NULL, 0, NULL);

    CreateThread(NULL, 0, ThreadPrco2, NULL, 0, NULL);

    Sleep(2*1000);
    system("pause");
    
    return 0;
}

----------------------------------------------------------------------------------------