Question

我有一个这三种方法的课程。许多线程都使用此类。如果Method2和/或Method3在任何线程中运行，我希望Method1等待。有什么建议吗？

public class Class1
{
    public static void Method1() 
    {
        Object lockThis = new Object();

        lock (lockThis)
        {
            //Body function
        }
    }

    public static void Method2() 
    {
         //Body function
    }

    public static void Method3() 
    {
         //Body function
    }
}

Answer 1

如果我理解正确，你需要这样的东西：

static object lockMethod2 = new object();
static object lockMethod3 = new object();

public static void Method1() 
{
    lock (lockMethod2)
    lock (lockMethod3)
    {
        //Body function
    }
}

public static void Method2() 
{
    lock (lockMethod2)
    {
        //Body function
    }
}

public static void Method3() 
{
    lock (lockMethod3)
    {
        //Body function
    }
}

这允许method3在method2运行时执行，反之亦然，而method1必须等待两者。当然，方法2和3在1运行时不会运行。

Answer 2

当前锁的实现完全没用，因为每个线程都会锁定不同的对象锁定通常使用只初始化一次的只读字段完成像这样，您可以轻松锁定多种方法：

public class Class1
{
    private static readonly object _syncRoot = new object();

    public static void Method1() 
    {
        lock (_syncRoot)
        {
            //Body function
        }
    }

    public static void Method2() 
    {
        lock (_syncRoot)
        {
            //Body function
        }
    }

    public static void Method3() 
    {
        lock (_syncRoot)
        {
            //Body function
        }
    }
}

Answer 3

我建议ReaderWriterLockSlim（http://msdn.microsoft.com/en-us/library/system.threading.readerwriterlockslim.aspx）

与读取操作类似，方法2和方法3可以并行发生，而Method1（如写入操作）需要等待那些完成。这不是常规的读/写并发情况，但逻辑是相似的。

public class Class1
{
    private ReaderWriterLockSlim methodLock = new ReaderWriterLockSlim();
    public static void Method1() 
    {
        methodLock.EnterWriteLock();
        try
        {
            //Body function
        }
        finally
        {
            methodLock.ExitWriteLock();
        }
    }

    public static void Method2() 
    {
         methodLock.EnterReadLock();
        try
        {
            //Body function
        }
        finally
        {
            methodLock.ExitReadLock();
        }
    }

    public static void Method3() 
    {
         methodLock.EnterReadLock();
        try
        {
            //Body function
        }
        finally
        {
            methodLock.ExitReadLock();
        }
    }
}

Answer 4

如果您是多线程，那么所有线程都必须可以访问lock。因此，在这种情况下，您的锁需要是静态的，静态方法才能看到它。

您当前的设置将为每个线程创建一个新的锁定对象。因此，现在提供同步。

c＃中的方法锁定

4 个答案: