C++中多线程管理

1，函数1 

CreateSemaphore

创建或打开一个信号量，信号可以理解为停车场，创建和增加信号，可以理解为创建一个停车场，和可以停放的汽车，

如下：

 CreateSemaphore(NULL, 2, 3, szSemaphoreA);//开始为signal状态

创建一个3个位置的停车场，但是初始只允许停两辆车

要全部允许停，使用方法。

ReleaseSemaphore(hSM_1, 1, NULL);

hSM_1 为（hSM_1 = CreateSemaphore(NULL, 2, 3, szSemaphoreA);） 上面创建的信号句柄。

全部函数如下：Thread_2，Thread_3，为后面预留

#include <Windows.h>
#include <iostream>
#include <semaphore>
#include <tchar.h>
using namespace System;
using namespace System::Runtime::InteropServices;




const TCHAR* szSemaphoreA = _T("_SemaphoreA_");
const TCHAR* szSemaphoreB = _T("_SemaphoreB_");
const TCHAR* szSemaphoreC = _T("_SemaphoreC_");

DWORD WINAPI Thread_1(LPVOID param);
DWORD WINAPI Thread_2(LPVOID param);
DWORD WINAPI Thread_3(LPVOID param);

HANDLE hSM_1;
HANDLE hSM_2;
HANDLE hSM_3;

HANDLE hThread_1;
HANDLE hThread_2;
HANDLE hThread_3;

int main()
{
    
    /*Marshal测试*/
    /*String^ s_adress = "127.0.0.1";
    char* pcbuf = (char*)Marshal::StringToHGlobalAnsi(s_adress).ToPointer();
    std::cout << pcbuf;
    std::cin >> pcbuf;*/
    /* Semaphore 线程同步的辅助类，可以维护当前访问自身的线程个数，
             并提供了同步机制。使用Semaphore可以控制同时访问资
             源的线程个数测试*/
   
    // 创建三个信号量CreateSemaphore , 
     /*此函数可用来创建或打开一个信号量，先看参数说明：
     lpSemaphoreAttributes：为信号量的属性，一般可以设置为NULL
     lInitialCount：信号量初始值，必须大于等于0，而且小于等于 lpMaximumCount，如果lInitialCount 的初始值为0，则该信号量默认为unsignal状态，如果lInitialCount的初始值大于0，则该信号量默认为signal状态，
     lMaximumCount： 此值为设置信号量的最大值，必须大于0
    lpName：信号量的名字，长度不能超出MAX_PATH ，可设置为NULL，表示无名的信号量。
    函数调用成功返回信号量句柄。*/
    hSM_1 = CreateSemaphore(NULL, 2, 3, szSemaphoreA);//开始为signal状态
    ReleaseSemaphore(hSM_1, 1, NULL);
    hSM_2 = CreateSemaphore(NULL, 0, 3, szSemaphoreB);//开始为unsignal状态，等待hSM_1释放
    hSM_3 = CreateSemaphore(NULL, 0, 3, szSemaphoreC);//开始为unsignal状态，等待hSM_2

    //创建三个线程

    hThread_1 = CreateThread(NULL, 0, Thread_1, NULL, 0, NULL);
    hThread_2 = CreateThread(NULL, 0, Thread_2, NULL, 0, NULL);
    hThread_3 = CreateThread(NULL, 0, Thread_3, NULL, 0, NULL);

    //等待三个线程都执行完
    WaitForSingleObject(hThread_1, INFINITE);
    WaitForSingleObject(hThread_2, INFINITE);
    WaitForSingleObject(hThread_3, INFINITE);

    //三个线程都执行完
    printf("\n\n\t main end \n");

    //关闭句柄
    CloseHandle(hThread_1);
    CloseHandle(hThread_2);
    CloseHandle(hThread_3);
    CloseHandle(hSM_1);
    CloseHandle(hSM_2);
    CloseHandle(hSM_3);
    return 0;

 }
DWORD WINAPI Thread_1(LPVOID param)
{
    for (int i = 0; i < 10; i++)
    {
        DWORD dwWait = WaitForSingleObject(hSM_1, INFINITE);

        //每一个wait过后信号量的数量自动减1，这样就达到了控制同步

        printf("A");
        /*按指定量增加指定的信号灯对象的计数。
        参数1 ：是要增加的信号量句柄。
        参数2 ：是增加的计数。        
        参数3 ：是增加前的数值返回。*/
        //ReleaseSemaphore(hSM_2, 1, NULL);
    }
    return 0;
}

DWORD WINAPI Thread_2(LPVOID param)
{
    for (int i = 0; i < 10; i++)
    {
        WaitForSingleObject(hSM_2, INFINITE);
        printf("B");
        //ReleaseSemaphore(hSM_3, 1, NULL);
    }
    return 0;
}

DWORD WINAPI Thread_3(LPVOID param)
{
    for (int i = 0; i < 10; i++)
    {
        WaitForSingleObject(hSM_3, INFINITE);
        printf("C ");
        ReleaseSemaphore(hSM_1, 1, NULL);
    }

    system("pause");
    return 0;
}

增加四个行得通吗，行不通得

除非先开一辆车出来，怎么开出来呢，使用方法 ，(WaitForSingleObject),消耗一个信号，

DWORD dwWait = WaitForSingleObject(hSM_1, INFINITE);

先消耗再增加就行了

DWORD WINAPI Thread_1(LPVOID param)
{
    for (int i = 0; i < 10; i++)
    {
        DWORD dwWait = WaitForSingleObject(hSM_1, INFINITE);
        //每一个wait过后信号量的数量自动减1，这样就达到了控制同步
        printf("A%d ",i);
        /*按指定量增加指定的信号灯对象的计数。
        参数1 ：是要增加的信号量句柄。
        参数2 ：是增加的计数。        
        参数3 ：是增加前的数值返回。*/
        ReleaseSemaphore(hSM_1, 1, NULL);
    }
   
    return 0;
}