互斥体（用户模式内核模式快速互斥体）

一.用户模式互斥体　　

　　创建互斥体：

　　HANDLE CreateMutex(
　　　　LPSECURITY_ATTRIBUTES lpMutexAttributes,   // pointer to security attributes

　　　　BOOL bInitialOwner, //始化时是否被占有
　　　　LPCTSTR lpName       // pointer to mutex-object name
       );

　　释放互斥体：

　　BOOL ReleaseMutex(
　　　　 HANDLE hMutex // handle to mutex object
　　);

　　代码内容：获得了互斥体之后，同一个线程中可以递归获得互斥体，就是得到互斥体的线程还可以再次获得这个互斥体，或者说互斥体对于已经获得互斥体的线程不产生”互斥”关系。

// Mutex-ThreadSynchronization.cpp : 定义控制台应用程序的入口点。
//
 
#include "stdafx.h"
#include <windows.h>
#include <iostream>
using namespace std;
//获得互斥体的线程不产生"互斥"关系(不互斥自己)
DWORD WINAPI ThreadProcedure(LPVOID ParameterData);
int main()
{
    HANDLE ThreadHandle[2] = {0};
    int i;
 
    HANDLE
    MutexHandle = CreateMutex(
        NULL,            
        FALSE,  //表明初始化时是否被占有          
        NULL);            
 
    if (MutexHandle == NULL)
    {
        printf("CreateMutex() Error\r\n");
        goto Exit;
    }
    for (i = 0; i < 2; i++)
    {
        ThreadHandle[i] = CreateThread(
            NULL,      
            0,         
            (LPTHREAD_START_ROUTINE)ThreadProcedure,
            (PVOID)&MutexHandle,       
            0,         
            NULL); 
 
        if (ThreadHandle[i] == NULL)
        {
            printf("CreateThread() Error\r\n");
            goto Exit;
        }
    }
    WaitForMultipleObjects(2, ThreadHandle, TRUE, INFINITE);
    for (i = 0; i < 2; i++)
        CloseHandle(ThreadHandle[i]);
Exit:
    {
        if (MutexHandle!=NULL)
        {
            CloseHandle(MutexHandle);
            MutexHandle = NULL;
        }
    }
    return 0;
}
 
DWORD WINAPI ThreadProcedure(LPVOID ParameterData)
{
    HANDLE MutexHandle = *((HANDLE*)ParameterData);
    DWORD Looping = 0;
    BOOL  IsOk = 0;
     
    //占有几次就必须解锁几次
    while (Looping < 5)
    {
        //占有互斥体
        IsOk = WaitForSingleObject(
            MutexHandle,
            INFINITE);   
        IsOk -= WAIT_OBJECT_0;
        switch (IsOk)
        {
        case WAIT_OBJECT_0:    //等待的对象变为已通知状态，那么返回值是WAIT_OBJECT_0。
        {
            __try {
 
                printf("ThreadID:%d\r\n",
                    GetCurrentThreadId());
                Looping++;
            }
 
            __finally {
 
                //释放互斥体
                if (!ReleaseMutex(MutexHandle))
                {
 
                }
            }
            break;
        }
        case WAIT_ABANDONED:
            return FALSE;
        }
    }
 
    printf("ThreadProcedure() Exit\r\n");
    return TRUE;
}

二.内核模式互斥体

　　1.互斥体在内核模式下的结构体为KMUTEX，使用前需要进行初始化：KeInitializeMutex，释放互斥体使用KeReleaseMutex内核函数

　　2.PsCreateSystemThread创建新的线程占用互斥体

　　3.ObReferenceObjectByHandle将句柄转化为指向object的指针，交给 KeWaitForMultipleObjects函数，用于同时等待一个或多个同步对象。

　　NTKERNELAPI
　　NTSTATUS
　　KeWaitForMultipleObjects (
　　　　_In_ ULONG Count, //数组中指针的个数
　　　　_In_reads_(Count) PVOID Object[], //指向一个指针数组
　　　　_In_ _Strict_type_match_ WAIT_TYPE WaitType, //等待所有对象都进入信号态
　　　　_In_ _Strict_type_match_ KWAIT_REASON WaitReason,
　　　　_In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE,__drv_typeConst) KPROCESSOR_MODE WaitMode,
　　　　_In_ BOOLEAN Alertable,
　　　　_In_opt_ PLARGE_INTEGER Timeout,
　　　　_Out_opt_ PKWAIT_BLOCK WaitBlockArray
);

#include <ntifs.h>
 
VOID SeCreateMutex();
VOID ThreadProcedure(PVOID ParameterData);
VOID DriverUnload(PDRIVER_OBJECT DriverObject);
 
 
NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegisterPath)
{
    NTSTATUS Status = STATUS_SUCCESS;
 
    PDEVICE_OBJECT  DeviceObject = NULL;
 
    DriverObject->DriverUnload = DriverUnload;
 
 
    SeCreateMutex();
    return Status;
}
 
 
VOID DriverUnload(PDRIVER_OBJECT DriverObject)
{
    DbgPrint("DriverUnload()\r\n");
}
 
VOID SeCreateMutex()
{
    KMUTEX  Mutex;
    HANDLE  ThreadHandle[2] = { 0 };
    ULONG   i = 0;
    PVOID   ThreadObject[2] = { 0 };
    KeInitializeMutant(&Mutex, 0);
    for (i = 0; i < 2; i++)
    {
        PsCreateSystemThread(&ThreadHandle[i], 0, NULL, NULL, NULL, ThreadProcedure, &Mutex);
    }
    for (i = 0; i < 2; i++)
    {
        //把线程句柄转换为可以等待的指针
        ObReferenceObjectByHandle(ThreadHandle[i], 0, NULL, KernelMode, &ThreadObject[i], NULL);
    }
    //等待2个新建线程执行完毕
    KeWaitForMultipleObjects(
        2,              //数组中指针的个数
        ThreadObject,   //指向一个指针数组
        WaitAll,        //等待所有对象都进入信号态
        Executive, 
        KernelMode, 
        FALSE, 
        NULL, 
        NULL);
    for (i = 0; i < 2; i++)
    {
        ObDereferenceObject(ThreadObject[i]);
        ZwClose(ThreadHandle[i]);
        ThreadHandle[i] = NULL;
    }
}
VOID ThreadProcedure(PVOID ParameterData)
{
    PKMUTEX Mutex = (PKMUTEX)ParameterData;
    int i = 0;
 
    //占有几次解锁几次
    for (i=0;i<3;i++)
    {
        KeWaitForSingleObject(Mutex, Executive, KernelMode, FALSE, NULL);
 
        //该函数是以微秒为单位
        KeStallExecutionProcessor(10000); //0.01秒   
 
        DbgPrint("ThreadID:%d\r\n",PsGetCurrentThreadId());
 
        KeReleaseMutex(Mutex, FALSE);
    }
    PsTerminateSystemThread(STATUS_SUCCESS);
 
    //当线程退出Mutex就不起作用了即使不解占有
}

三.快速互斥体

　　快速互斥体是DDK提供的另外一种内核同步对象，他的特征类似于前面介绍的普通互斥体。他们两的作用完全一样，之所以被称为是快速互斥体，是因为它执行的速度比普通的互斥体速度快（这里指的是获取和释放的速度）。然而，快速互斥体对象不能被递归获取。

　　普通互斥体在内核中用KMUTEX数据结构表示，而快速互斥体在内核中用FAST_MUTEX数据结构描述。

除此之外，对快速互斥体的初始化，获取和释放对应的内核函数也和普通互斥体不同。

　　初始化：
　　VOID
ExInitializeFastMutex(
　　 IN PFAST_MUTEX FastMutex
   　　 );
　　获取：
　　VOID
　 ExAcquireFastMutex(
   　　 IN PFAST_MUTEX FastMutex
);
　　释放：
　　VOID
　 ExReleaseFastMutex(
　　 IN PFAST_MUTEX FastMutex
   　 );

#include <ntifs.h>
VOID SeCreateFastMutex();
VOID ThreadProcedure(PVOID ParameterData);
VOID DriverUnload(PDRIVER_OBJECT DriverObject);
 
 
NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegisterPath)
{
    NTSTATUS Status = STATUS_SUCCESS;
    PDEVICE_OBJECT  DeviceObject = NULL;
    DriverObject->DriverUnload = DriverUnload;
    SeCreateFastMutex();
    return Status;
}
VOID DriverUnload(PDRIVER_OBJECT DriverObject)
{
    DbgPrint("DriverUnload()\r\n");
}
VOID SeCreateFastMutex()
{
    HANDLE  ThreadHandle[2] = { 0 };
    FAST_MUTEX  Mutex;
    ULONG   i = 0;
    PVOID   ThreadObject[2] = { 0 };
 
    ExInitializeFastMutex(&Mutex);
 
    for (i = 0; i < 2; i++)
    {
        PsCreateSystemThread(&ThreadHandle[i], 0, NULL, NULL, NULL, ThreadProcedure, &Mutex);
    }
    for (i = 0; i < 2; i++)
    {
        ObReferenceObjectByHandle(ThreadHandle[i], 0, NULL, KernelMode, &ThreadObject[i], NULL);
    }
    KeWaitForMultipleObjects(2, ThreadObject, WaitAll, Executive, KernelMode, FALSE, NULL, NULL);
    for (i = 0; i < 2; i++)
    {
        ObDereferenceObject(ThreadObject[i]);
        ZwClose(ThreadHandle[i]);
        ThreadHandle[i] = NULL;
    }
}
 
VOID ThreadProcedure(PVOID ParameterData)
{
    PFAST_MUTEX  Mutex = (PFAST_MUTEX)ParameterData;;
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        ExAcquireFastMutex(Mutex);
        //该函数是以微秒为单位
        KeStallExecutionProcessor(10000); //0.01秒   
        DbgPrint("ThreadID:%d\r\n", PsGetCurrentThreadId());
        ExReleaseFastMutex(Mutex);        //如果当前线程不解锁就互斥住自己
 
    }
    PsTerminateSystemThread(STATUS_SUCCESS);
}