【av68676164（p31-p32)】Windows和Linux同步机制

2022-12-29 09:37:58

4.6.1 Windows同步机制

临界区（CRITICAL_SECTION）

  • 在进程内使用，保证仅一个线程可以申请到该对象
  • 临界区内是临界资源的访问

相关的API函数

初始化临界区
WINBASEAPI

VOID

WINAPI

InitializeCriticalSection(

    _Out_ LPCRITICAL_SECTION lpCriticalSection

    );
删除临界区
WINBASEAPI

VOID

WINAPI

DeleteCriticalSection(

    _Inout_ LPCRITICAL_SECTION lpCriticalSection

    );
退出临界区（开锁）
WINBASEAPI

VOID

WINAPI

LeaveCriticalSection(

    _Inout_ LPCRITICAL_SECTION lpCriticalSection

    );

例子

/*用3个线程共同把nSum累加到240*/

#include <cstdio>

#include <Windows.h>

#define INF 0x7fffffff

//全局变量

int nSum = 0;

const int NUMBER = 80;

//累加线程函数

DWORD WINAPI Accumulate(LPVOID lpParam) {

    for (int i = 0; i < NUMBER; i++) {

        //多个线程同时就绪，让nSum不唯一

        int iCopy = nSum;

        nSum = iCopy + 1;

    }

    return 0;

}

int main() {

    HANDLE hThread[3];

    hThread[0] = CreateThread(nullptr, 0, Accumulate, nullptr, 0, nullptr);

    hThread[1] = CreateThread(nullptr, 0, Accumulate, nullptr, 0, nullptr);

    hThread[2] = CreateThread(nullptr, 0, Accumulate, nullptr, 0, nullptr);

    //等待这三个线程结束之后才能返回

    WaitForMultipleObjects(3, hThread, true, INF);

    printf("nSum = %d\n", nSum);

    system("pause");

    return EXIT_SUCCESS;

}

结果可能会出现不是240的情况

【av68676164（p31-p32)】Windows和Linux同步机制

等待函数

功能：等待目标对象变成有信号的状态返回

WINBASEAPI

DWORD

WINAPI

WaitForMultipleObjects(

    _In_ DWORD nCount,							// 等待的目标对象的数量

    _In_reads_(nCount) CONST HANDLE* lpHandles, // 目标对象的句柄

    _In_ BOOL bWaitAll,							// 等待方式

    _In_ DWORD dwMilliseconds					// 等待时间，单位是毫秒

    );

等待单个对象：

WINBASEAPI

DWORD

WINAPI

WaitForSingleObject(

    _In_ HANDLE hHandle,				// 等待的目标对象的句柄

    _In_ DWORD dwMilliseconds			// 等待时间，单位是毫秒

    );

修改

/*用3个线程共同把nSum累加到240*/

#include <cstdio>

#include <Windows.h>

#define INF 0x7fffffff

//全局变量

int nSum = 0;

const int NUMBER = 80;

//定义临界区对象

CRITICAL_SECTION cs;

//累加线程函数

DWORD WINAPI Accumulate(LPVOID lpParam) {

    for (int i = 0; i < NUMBER; i++) {

        //进入临界区 P(S)

        EnterCriticalSection(&cs);

        //多个线程同时就绪，让nSum不唯一

        int iCopy = nSum;

        nSum = iCopy + 1;

        //退出临界区 V(S)

        LeaveCriticalSection(&cs);

    }

    return 0;

}

int main() {

    //初始化临界区对象

    InitializeCriticalSection(&cs);

    HANDLE hThread[3];

    hThread[0] = CreateThread(nullptr, 0, Accumulate, nullptr, 0, nullptr);

    hThread[1] = CreateThread(nullptr, 0, Accumulate, nullptr, 0, nullptr);

    hThread[2] = CreateThread(nullptr, 0, Accumulate, nullptr, 0, nullptr);

    //等待这三个线程结束之后才能返回

    WaitForMultipleObjects(3, hThread, true, INF);

    printf("nSum = %d\n", nSum);

    system("pause");

    return EXIT_SUCCESS;

}

【av68676164（p31-p32)】Windows和Linux同步机制

互斥量（Mutex）

  • 保证只有1个线程或进程可以申请到该对象
  • 可以跨进程使用
  • 可以有名称
  • 互斥量比临界区要耗费更多资源，速度慢

用在互斥量上的函数

//创建互斥量

WINBASEAPI

_Ret_maybenull_

HANDLE

WINAPI

CreateMutexW(

    _In_opt_ LPSECURITY_ATTRIBUTES lpMutexAttributes,

    _In_ BOOL bInitialOwner,		//初始化互斥量的状态：真或假

    _In_opt_ LPCWSTR lpName			//名字，可为null但不能跨进程用

    );
//打开一个存在的互斥量

WINBASEAPI

_Ret_maybenull_

HANDLE

WINAPI

OpenMutexW(

    _In_ DWORD dwDesiredAccess,

    _In_ BOOL bInheritHandle,

    _In_ LPCWSTR lpName		//名字

    );
WINBASEAPI

BOOL

WINAPI

ReleaseMutex(

    _In_ HANDLE hMutex

    );


//关闭互斥量

WINBASEAPI

BOOL

WINAPI

CloseHandle(

    _In_ _Post_ptr_invalid_ HANDLE hObject	//句柄

    );

信号量（Semaphore）

  • 允许指定数目的多个进程/进程访问临界区
  • 一种资源计数器，用于限制并发线程的数量
  • 初始值可设为N，则表示允许N个进程/线程并发访问资源

用于信号量操作的API函数

//创建信号量

WINBASEAPI

HANDLE

WINAPI

CreateSemaphoreW(

    _In_opt_ LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,	//安全属性

    _In_ LONG lInitialCount,	//初始值

    _In_ LONG lMaximumCount,	//最大值

    _In_opt_ LPCWSTR lpName		//名字

    );
//打开信号量

WINBASEAPI

_Ret_maybenull_

HANDLE

WINAPI

OpenSemaphoreW(

    _In_ DWORD dwDesiredAccess,		//存取方式

    _In_ BOOL bInheritHandle,		//能否被继承

    _In_ LPCWSTR lpName				//名字

    );
//释放信号量

WINBASEAPI

BOOL

WINAPI

ReleaseSemaphore(

    _In_ HANDLE hSemaphore,				//句柄

    _In_ LONG lReleaseCount,			//释放数，使信号量的值增加的数量

    _Out_opt_ LPLONG lpPreviousCount	//得到释放前信号量的值

    );
//关闭信号量

WINBASEAPI

BOOL

WINAPI

CloseHandle(

    _In_ _Post_ptr_invalid_ HANDLE hObject	//句柄

    );

信号量的值可以通过相应的函数增或减

  • WaitForSingleObject()将信号量增1
  • ReleaseSemaphore将信号量增1

信号状态

  • 信号量的值大于0时，有信号状态
  • 信号量的值小于等于0时，为无信号状态

使用信号量限制临界区访问的例子

#include <cstdio>

#include <Windows.h>

#define INF 0x7fffffff

//线程函数

DWORD AcessDB(void* pD) {

	HANDLE hSu = OpenSemaphore(SEMAPHORE_ALL_ACCESS, (LPWSTR)L"SU");

	while (true) {

		WaitForSingleObject(hSu, INF);

		//此处时模拟数据库访问

		printf("Do database access!\n");

		Sleep(100);

		ReleaseSemaphore(hSu, 1, nullptr);

	}

}

int main() {

	//创建信号灯

	HANDLE hSU = nullptr;

	//功能：信号量初始值为2，保证最多只有2个线程可以同时进行数据库访问

	hSU = CreateSemaphore(nullptr, 2, 2, (LPWSTR)L"SU");

	//创建三个线程

	HANDLE hThread[3];

	CWinThread* pT1 = AfxBeginThread(AccessDB, (void*)1);

	CWinThread* pT2 = AfxBeginThread(AccessDB, (void*)2);

	CWinThread* pT3 = AfxBeginThread(AccessDB, (void*)3);

	hThread[0] = pT1->m_hThread;

	hThread[1] = pT2->m_hThread;

	hThread[2] = pT3->m_hThread;

	WaitForMultipleObjects(3, hThread, true, INF);

	//关闭句柄

	CloseHandle(hSU);

	return EXIT_SUCCESS;

}

事件（Event）

用于通知一个或多个线程某事件出现或某操作已经完成

事件对象的分类

  • 自动重置的事件：使用WaitForSingleObject等待到事件对象变为有信号状态后该事件对象自动变为无信号状态
  • 人工重置的事件：使用WaitForSingleObject等待到事件对象变为有信号状态后该事件对象的状态不变，除非人工重置

Windows同步机制

临界区对象
EnterCriticalSection(); P操作
LeaveCriticalSection(); V操作
互斥量对象
ReleaseMutex() V操作
事件对象
Bool SetEvent() V操作
信号量对象
CreateSemaphore()
ReleaseSemaphore() V操作
等待机制
WaitForSingleObject() P操作

4.6.2 Linux同步机制

思考：程序运行流程？pid_1和pid_2的值

/*

	先运行子进程，打印子进程的pid，然后返回父进程，父进程打印返回回来的子进程的pid

*/

#include <iostream>

#include <unistd.h>

int main() {

    pid_t pid, pid_1, pid_2;

    pid = fork();

//    子进程

    if (pid == 0) {

        pid_1 = getpid();

        printf("pid1 = %d \n", pid_1);

        sleep(10);

    }

//    父进程

    if (pid > 0) {

//      返回子进程的id号

//      子进程运行结束后，进入僵尸态，父进程来进行善后工作-

        pid_2 = wait(nullptr);

        printf("pid2 = %d\n", pid_2);

    }

    exit(0);

}

进程的阻塞wait()

进程调用wait(int status)会阻塞自己

父进程调用wait函数做善后工作

  • 阻塞到有是否有子进程结束？
    • 没有：进程一直阻塞
    • 有（僵尸进程）
      • wait收集该子进程信息并彻底销毁子进程后返回
  • status保存进程退出时的状态
    • 若忽略推出信息
      • pid = wait(nullptr);

进程的终结exit()

  • 调用void exit(int status)终结进程
  • 进程终结时要释放资源并报告父进程
    • 利用status传递进程结束时的状态
    • 变为僵尸状态，保留部分PCB信息供wait收集
      • 正常结束还是异常结束
      • 占用总系统cpu事件
      • 缺页中断次数
    • 调用schedule()函数，选择新进程运行

进程的休眠

  • sleep(int nSecond)
    • 进程暂停执行nSecond秒
    • 系统暂停调度该进程
    • 相当于windows的suspend()，挂起若干秒

【av68676164（p31-p32)】Windows和Linux同步机制

【av68676164（p31-p32)】Windows和Linux同步机制

父子共享普通变量

#include <iostream>

#include <unistd.h>

int main() {

    pid_t pid;

    int i = 1;

//    创建新进程

    pid = fork();

//    子进程

    if (pid == 0) {

        i = 2;

        printf("In child i = %d\n", i);

        exit(0);

    } else {

//        十秒休眠，让子进程先执行

        sleep(10);

        printf("In parent i = %d\n", i);

        exit(0);

    }

}

【av68676164（p31-p32)】Windows和Linux同步机制

结论：对于普通变量，父子进程各自操作变量副本，互相不影响

父子进程共享文件资源

对于文件，父子进程共享同一文件和读写指针

上一篇：ldap日志


下一篇：ArcGIS Server的切图原理深入（转载）