C#中如何发现Mutex被获取了？

Question

如何从 C# 中的互斥体句柄中找到已获取互斥体？

当 mutex.WaitOne(timeout) 超时时，它返回 false。但是，我如何从互斥体句柄中找到它？ （也许使用 p/invoke。）

更新：

public class InterProcessLock : IDisposable
{
    readonly Mutex mutex;

    public bool IsAcquired { get; private set; }

    public InterProcessLock(string name, TimeSpan timeout)
    {
        bool created;
        var security = new MutexSecurity();
        security.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.Synchronize | MutexRights.Modify, AccessControlType.Allow));
        mutex = new Mutex(false, name, out created, security);
        IsAcquired = mutex.WaitOne(timeout);
    }

    #region IDisposable Members

    public void Dispose()
    {
        if (IsAcquired)
        {
            mutex.ReleaseMutex();
            IsAcquired = false;
        }
    }

    #endregion
}

目前，我正在使用自己的属性 IsAcquired 来确定是否应该释放互斥体。不是必需的，但更清楚的是，不使用 IsAcquired 属性表示的信息的辅助副本，而是直接询问互斥体是否由我获取。因为如果我没有获取它，调用 mutex.ReleaseMutex() 会抛出异常。

（通过获得状态，我的意思是当我拥有互斥体时，互斥体处于未发出信号状态。）

（编辑：我已添加IsAcquired = false; 感谢 mattdekrey 的帖子。）

Answer 1

之所以没有干净的方法来做到这一点，是因为这不是一个好主意，而且原因是，当您依赖这种类型的逻辑时，竞争条件很容易引入。所以你的设计需要改变。

首先，您不应该在构造函数中获取锁。将此类转换为返回正确初始化的互斥对象的工厂。这样你就可以知道你是否获得了锁。

不要依赖 Dispose 来释放锁，这会导致死锁缠身的代码难以维护。使用 try/finally 块来确保它被释放。

超时有点粗略。只有在未获取锁时才使用超时才被视为正常操作。无法获取锁通常是一个错误，而仅仅通过超时来避免它会隐藏该错误。如果您需要超时，请考虑使用事件（可能是 AutoResetEvent），这可能更合适。

Answer 2

您可能会发现，Mutex 类上没有公共成员：
http://msdn.microsoft.com/en-us/library /system.threading.mutex_members.aspx

也没有公共本机函数：
http://msdn.microsoft.com/en -us/library/ms686360%28v=VS.85%29.aspx

但是，有一些未记录/不受支持的函数，特别是在 ntdll.dll 中。这些允许访问系统对象。但是，这些功能可能会在未来版本的操作系统中发生变化或不可用。

所以，答案是：使用常规手段是不可能的。

Answer 3

好吧，这并不完全是您所要求的，但我认为它可以解决您的问题：为什么不专门针对互斥体被其他人获取时发生的异常添加一些错误处理呢？

public void Dispose()
{
    if (IsAcquired)
        try
        { mutex.ReleaseMutex(); }
        catch (System.Threading.SynchronizationLockException)
        {
            // Handle the exception, assuming you need to do anything.
            // All other exceptions would still be passed up the stack.
        }
}

Answer 4

为什么你不能使用 Mutex.OpenExisting

try
{
    Mutex foundMutex = Mutex.OpenExisting("MyTestingMutex");

    // Found Mutex
    foundMutex.ReleaseMutex();
}
catch (System.Threading.WaitHandleCannotBeOpenedException)
{
    //   System.Threading.WaitHandleCannotBeOpenedException:
    //     The named mutex does not exist.
}

编辑

我猜测其中一些。

看起来你正在尝试开发一个 API。您在 API 中提供的项目之一是 InterProcessLock。

我假设您正在跨线程共享一个集合，并且您正在使用互斥体来确保一次只有一个操作。

using (InterProcessLock myLock = new InterProcessLock("LockMutex", TimeSpan.FromMilliseconds(100.0)))
{
    if(myLock.IsAcquired)
    {
        // I have control then I can delete, add to the collection.
    }
}

我会重新考虑这个设计。如果我从未将 InterProcessLock myLock = new InterProcessLock("LockMutex", TimeSpan.FromMilliseconds(100.0)) 包装在 using 中怎么办？不会调用 Dispose。如果用户根本不调用 Dispose 会怎样？

将会有一个废弃的互斥锁

来自 MSDN

注意
废弃的互斥体通常表明代码中存在严重错误。当线程退出而未释放互斥体时，受互斥体保护的数据结构可能不会处于一致状态。如果可以验证数据结构的完整性，则请求互斥体所有权的下一个线程可以处理此异常并继续。

如果您试图保护您的用户，您可能希望通过控制他们的互斥体来帮助他们，这样他们就不必担心它。

一个可能的例子是

public static bool PerformLockedProcess(Action process, string commonLockName, TimeSpan timeout)
{
    Mutex mutex = null;

    // Get the Mutex for the User
    try
    {
        bool created;
        var security = new MutexSecurity();
        security.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.Synchronize | MutexRights.Modify, AccessControlType.Allow));

        mutex = new Mutex(false, commonLockName, out created, security);

        bool acquired = mutex.WaitOne(timeout);

        if (acquired)
        {
            process();

            return true;
        }

        return false;
    }
    finally
    {
        // Make sure we do not abandon the Mutex
        if (mutex != null)
        {
            try
            {
                mutex.ReleaseMutex();
            }
            catch (ApplicationException)
            {
                // In case that failes
            }
        }
    }
}

这是一种可能的方式。这完全取决于目标是什么。我不会依赖最终用户来调用 Dispose，因为互斥锁是一种操作系统构造。如果名称不明确，它可能会影响使用相同互斥体名称的其他进程。

Answer 5

这不会有利于问题的原始发布者，但就这样。

虽然我并不反对其他关于正确使用互斥锁的发帖者的观点，但我有一个应用程序，我需要测试某人是否拥有互斥锁，而无需我自己取得所有权。正如其他人提到的，唯一的方法是使用来自 ntdll.dll 的未记录的 NtQueryMutant 系统调用。我为 Mutex 类创建了一个扩展方法，可以像这样使用：

        bool createdNew = true;
        var m = new Mutex(false, MutexName, out createdNew);
        if ( m != null)
        {
            int currentCount;
            bool ownedByCaller, abandonedState;
            if (m.TryQuery(out currentCount, out ownedByCaller, out abandonedState))
            {
                Console.WriteLine(string.Format("Created New: {3}, Count: {0}, OwvedByMe: {1}, Abandoned: {2}",
                    currentCount, ownedByCaller, abandonedState, createdNew));
            }
            m.Close();
        }

这是实现

public static class MutexExtensionMethods
{
    public static bool TryQuery(this Mutex m, out int currentCount, out bool ownedByCaller, out bool abandonedState)
    {
        currentCount = -1;
        ownedByCaller = abandonedState = false;
        try
        {
            var handle = m.SafeWaitHandle;
            if (handle != null)
            {
                var h = handle.DangerousGetHandle();
                MutantBasicInformation mbi;
                int retLength;
                var ntStatus = NtQueryMutant(
                    h,
                    MutantInformationClass.MutantBasicInformation,
                    out mbi, 
                    Marshal.SizeOf(typeof(MutantBasicInformation)),
                    out retLength);
                GC.KeepAlive(handle); // Prevent "handle" from being collected before NtQueryMutant returns
                if (ntStatus == 0)
                {
                    currentCount   = mbi.CurrentCount;
                    ownedByCaller  = mbi.OwnedByCaller;
                    abandonedState = mbi.AbandonedState;
                    return true;
                }
            }
        }
        catch
        {
        }
        return false;
    }

    #region NTDLL.DLL

    [DllImport("ntdll.dll")]
    public static extern uint NtQueryMutant(
        [In] IntPtr MutantHandle,
        [In] MutantInformationClass MutantInformationClass,
        [Out] out MutantBasicInformation MutantInformation,
        [In] int MutantInformationLength,
        [Out] [Optional] out int ReturnLength
        );

    public enum MutantInformationClass : int
    {
        MutantBasicInformation
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct MutantBasicInformation
    {
        public int CurrentCount;
        [MarshalAs(UnmanagedType.U1)]
        public bool OwnedByCaller;
        [MarshalAs(UnmanagedType.U1)]
        public bool AbandonedState;
    }

    #endregion

}

Answer 6

.NET Mutex 类是本机互斥体包装器，它提供了与本机互斥体 API 相同的可能性（除了等待不同类型的可等待对象的数量）。如果您想在不阻塞的情况下获取互斥锁，请调用mutex.WaitOne(0)。使用 PInvoke，您可以调用 WaitForSingleObject，得到相同的结果。

Answer 7

如果您确实尝试进行进程间锁定，顾名思义，您将需要一种方法来检测互斥锁是否实际上已被获取，对吗？我不确定如果没有 IsAcquired 属性，如何确保使用 InterProcessLock 的代码被锁定。 （此外，为了防止程序员意外调用 Dispose 两次，我在 Dispose 方法中将 IsAcquired 设置为 false。

）我自己实现了同样的事情（因为我更喜欢使用 using 块而不是 try-finally 只是为了释放互斥体），而是在超过超时时抛出异常，如果我正确地记得该项目，则不会调用处置方法。

编辑：
在构造函数中抛出异常的额外好处：您的临界区也完全避免了，并且您可以在 catch 块中执行错误处理，无论如何，这可能包括与您的临界区相同的方法调用，尽管我个人认为这是一种不好的做法。

经过进一步思考，您可以在处置中使用以下内容，而不是使用另一个答案中指定的 try ... catch ：

public void Dispose()
{
    if (IsAcquired)
    {
        lock (mutex) 
        {
            mutex.ReleaseMutex();
            IsAcquired = false;
        }
    }
}

锁定互斥体感觉有点讽刺，但是你已经有了。虽然我完全同意您不应该依赖于 IDisposable 接口的文档而调用 Dispose，但我认为拥有一个由 using() { }块。