Блог

Существует ли в .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 одновременно (одновременно «активен» только один сегмент. Если выполняется сегмент 1, другой поток должен иметь возможность выполнять Сегмент1, но не Сегмент2.

Правка 2

Учитывая все комментарии / ответы и мой реальный сценарий, я понимаю, что требовать, чтобы Segment2 был доступен несколькими потоками, немного безумно.

Это довольно необычная модель защиты ресурсов от неправильного одновременного доступа. Сначала я бы подумал, нельзя ли перевести ваш вариант использования в эквивалентный сценарий, где вы можете использовать простые блокировки. Если бы вы могли предоставить более подробную информацию о том, зачем вам нужна такая схема блокировки, возможно, сообщество предложило бы другие идеи.

Чтобы ответить на ваш конкретный вопрос, ничто в .NET или даже Win32 напрямую не поддерживает эту модель блокировки, однако вы можете создать ее из других примитивов. Я бы рассмотрел возможность использования пары ReaderWriterLockSlim экземпляров для защиты каждого ресурса. Когда потоки входят в SegmentA, вы получаете блокировку чтения на запись для A и блокировку записи B … и наоборот для потоков, входящих в SegmentB. Это позволило бы нескольким потокам выполняться в каждом сегменте, но не одновременно.

РЕДАКТИРОВАТЬ: Учитывая ваш ответ в комментариях к вашему вопросу, я более убежден, что вам нужно рассмотреть возможность использования модели блокировки чтения / записи. То, что вы ищете, — это способ защитить ресурс таким образом, чтобы, когда «авторы» выполняют работу (сериализуют словарь), ни читатели, ни другие авторы не могли войти, и когда «читатели» выполняют работу, они не блокируют друг друга, но блокируют всех других авторов. Это классический случай блокировок чтения / записи.

ПРАВКА 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

Учитывая вашу правку, похоже, что правильным подходом было бы использовать 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();
    }
}
  

Что-то вроде этого.

     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
            amp;amp;
            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
            amp;amp;
            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/