.net 构造/模式按代码段而不是线程阻塞

Question

.net 中是否有一个结构或模式定义了一段代码可以被多个线程访问，但如果任何线程在其他代码段中则阻塞（反之亦然）？例如：

void SomeOperationA()
{
    Block( B ) 
    {   
        Segment1: 
        ... only executes if no threads are executing in Segment2 ... 
    }    
}

}

void SomeOperationB()
{
    Block( A ) 
    { 
        Segment2: 
        ... only executes if no threads are executing in Segment1 ... 
    }     
}

编辑
几个线程应该能够同时访问 Segment1/Segment2（一次只有一个 Segment 处于“活动状态”。如果 Segment 1 正在执行，另一个线程应该能够执行 Segment1 而不是 Segment2。

编辑 2
鉴于所有 cmets/回复和我的真实场景，我意识到要求 Segment2 由多线程访问有点疯狂。

Answer 1

这是保护资源免受不当并发访问的一种相当不寻常的模型。我首先会考虑您的用例是否不能转换为可以使用简单锁的等效场景。如果您能提供更多关于为什么需要这种锁定方案的详细信息，那么社区可能会提供其他想法。

为了解决您的具体问题，.NET 甚至 Win32 中都没有直接支持此锁定模型，但是您可以使用其他原语构建它。 我会考虑使用一对ReaderWriterLockSlim 实例来保护每个资源。当线程进入 SegmentA 时，您将获得 A 上的写读锁和 B 上的写锁......反之亦然，线程进入 SegmentB。这将允许多个线程在每个段内执行，但不能同时执行。

编辑：鉴于您在 cmets 中对您的问题的回复，我更确信您需要考虑使用 Reader/Writer 锁定模型。您是什么寻找是一种保护资源的方法，这样当“作者”正在工作（序列化字典）时，没有读者或其他作者可以进入，而当“读者”正在工作时，他们不会相互阻止，而是阻止所有其他作者.这是读写器锁的经典案例。

编辑 2：现在我有更多时间，我认为有一点值得详细说明。考虑锁的方式是它们保护数据资源（内存、文件等）而不是代码区域。我们需要定义一次只有一个线程可以进入的代码的关键部分这一事实是一个实现细节，人们不应将其与共享资源的使用方式（并且必须受到保护）混淆。在您的问题中，关注如何控制哪些线程可以进入哪一部分代码会误导真正的问题：您试图保护哪些数据资源免受哪些类型的更改。一旦你从这个角度看待问题，就会更清楚哪些实现范式是有意义的。

这里有一些关于读写器锁定模型的好资源：

http://msdn.microsoft.com/en-us/magazine/cc163599.aspx

http://msdn.microsoft.com/en-us/library/bz6sth95.aspx

http://blogs.msdn.com/b/vancem/archive/2006/03/29/564854.aspx

Answer 2

鉴于您的编辑，听起来正确的方法是使用ReaderWriterLockSlim，因为您真的不应该在 Segment2 运行时修改集合，并且您不应该允许超过 1 个 Segment2 运行：

private static ReaderWriterLockSlim readerLock = new ReaderWriterLockSlim();
void SomeOperationA()
{
    try
    {  
        readerLock.EnterReadLock(); 
        // Segment1: 
        // ... only executes if no threads are executing in Segment2 ... 
    }    
    finally
    {
        readerLock.ExitReadLock();
    }
}

void SomeOperationB()
{
    try
    {  
        readerLock.EnterWriteLock(); 
        // Prevents multiple Segment2 from serializing, and prevents all Segment1 threads...
    }    
    finally
    {
        readerLock.ExitWriteLock();
    }
}

Answer 3

有点像。

    class Segments
    {
        public const int None = 0;
        public const int Segm1 = 1;
        public const int Segm2 = 2;
    }

    int currentSegm = 0;
    int segm1counter = 0;
    int segm2counter = 0;

    object segm1lock = new object();
    object segm2lock = new object();

    void SomeOperationA()
    {
        while (
            Interlocked.CompareExchange(ref currentSegm, Segments.Segm1, Segments.Segm1) != Segments.Segm1
            &&
            Interlocked.CompareExchange(ref currentSegm, Segments.Segm1, Segments.None) != Segments.None
            )
        {
            Thread.Yield();
        }

        Interlocked.Increment(ref segm1counter);
        try
        {

            //Segment1: 
            //... only executes if no threads are executing in Segment2 ...                 
        }
        finally
        {
            lock (segm1lock)
            {
                if (Interlocked.Decrement(ref segm1counter) == 0)
                    currentSegm = Segments.None;
            }
        }
    }


    void SomeOperationB()
    {
        while (
            Interlocked.CompareExchange(ref currentSegm, Segments.Segm2, Segments.Segm2) != Segments.Segm2
            &&
            Interlocked.CompareExchange(ref currentSegm, Segments.Segm2, Segments.None) != Segments.None
            )
        {
            Thread.Yield();
        }

        Interlocked.Increment(ref segm2counter);
        try
        {

            //Segment2: 
            //... only executes if no threads are executing in Segment2 ...                 
        }
        finally
        {
            lock (segm2lock)
            {
                if (Interlocked.Decrement(ref segm2counter) == 0)
                    currentSegm = Segments.None;
            }
        }
    }

好的，它不适用于 ReaderWriter 锁定/