WindowsPlatformMutex.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Timespan.h"
 
class FString;
 
namespace UE
{
 
class FWindowsRecursiveMutex final
{
public:
    FWindowsRecursiveMutex(const FWindowsRecursiveMutex&) = delete;
    FWindowsRecursiveMutex& operator=(const FWindowsRecursiveMutex&) = delete;
 
    inline FWindowsRecursiveMutex()
    {
        CA_SUPPRESS(28125);
        Windows::InitializeCriticalSectionAndSpinCount(&CriticalSection, 4000);
    }
 
    UE_FORCEINLINE_HINT ~FWindowsRecursiveMutex()
    {
        Windows::DeleteCriticalSection(&CriticalSection);
    }
 
    UE_FORCEINLINE_HINT bool TryLock()
    {
        return !!Windows::TryEnterCriticalSection(&CriticalSection);
    }
 
    UE_FORCEINLINE_HINT void Lock()
    {
        Windows::EnterCriticalSection(&CriticalSection);
    }
 
    UE_FORCEINLINE_HINT void Unlock()
    {
        Windows::LeaveCriticalSection(&CriticalSection);
    }
 
private:
    Windows::CRITICAL_SECTION CriticalSection;
};
 
class FWindowsSharedMutex final
{
public:
    FWindowsSharedMutex(const FWindowsSharedMutex&) = delete;
    FWindowsSharedMutex& operator=(const FWindowsSharedMutex&) = delete;
 
    FWindowsSharedMutex() = default;
 
    ~FWindowsSharedMutex()
    {
        checkf(!IsLocked(), TEXT("Destroying a lock that is still held!"));
    }
 
    UE_FORCEINLINE_HINT bool TryLock()
    {
        return !!Windows::TryAcquireSRWLockExclusive(&Mutex);
    }
 
    UE_FORCEINLINE_HINT void Lock()
    {
        Windows::AcquireSRWLockExclusive(&Mutex);
    }
 
    UE_FORCEINLINE_HINT void Unlock()
    {
        Windows::ReleaseSRWLockExclusive(&Mutex);
    }
 
    UE_FORCEINLINE_HINT bool TryLockShared()
    {
        return !!Windows::TryAcquireSRWLockShared(&Mutex);
    }
 
    UE_FORCEINLINE_HINT void LockShared()
    {
        Windows::AcquireSRWLockShared(&Mutex);
    }
 
    UE_FORCEINLINE_HINT void UnlockShared()
    {
        Windows::ReleaseSRWLockShared(&Mutex);
    }
 
private:
    bool IsLocked()
    {
        if (Windows::TryAcquireSRWLockExclusive(&Mutex))
        {
            Windows::ReleaseSRWLockExclusive(&Mutex);
            return false;
        }
        return true;
    }
 
    Windows::SRWLOCK Mutex = { 0 }; // SRWLOCK_INIT
};
 
class FWindowsSystemWideMutex final
{
public:
    FWindowsSystemWideMutex(const FWindowsSystemWideMutex&) = delete;
    FWindowsSystemWideMutex& operator=(const FWindowsSystemWideMutex&) = delete;
 
    CORE_API explicit FWindowsSystemWideMutex(const FString& InName, FTimespan InTimeout = FTimespan::Zero());
 
    CORE_API ~FWindowsSystemWideMutex();
 
    CORE_API bool IsValid() const;
 
    CORE_API void Release();
 
private:
    Windows::HANDLE Mutex;
};
 
using FPlatformRecursiveMutex = FWindowsRecursiveMutex;
using FPlatformSharedMutex = FWindowsSharedMutex;
using FPlatformSystemWideMutex = FWindowsSystemWideMutex;
 
} // UE
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "HAL/PlatformMemory.h"
#endif