Common Intermediate Language и системное программирование в Microsoft.Net. Макаров А.В - 141 стр.

268                        CIL и системное программирование в Microsoft .NET   Разработка параллельных приложений для ОС Windows                       269


     Приведенный пример показывает синхронизацию с использованием                        private int          m_a = 0, m_b = 0;
мьютекса, события с ручным сбросом и объекта WaitHandle, представляюще-                  public int summ() {
го состояние асинхронного вызова. В примере делается 10 асинхронных вы-                     int r;
зовов, после чего приложение ожидает завершения всех вызовов с помощью                      m_rwlock.AcquireReaderLock( -1 );
метода WaitAll. Каждый асинхронный метод в секции кода, защищаемой                          try {
мьютексом (здесь было бы эффективнее использовать монитор или блоки-                          r = m_a; Thread.Sleep( 1000 ); return r + m_b;
ровку), подсчитывает число сделанных вызовов и переходит к ожиданию за-                     } finally {
нятого события. Самый последний асинхронный вызов установит событие в                         m_rwlock.ReleaseReaderLock();
свободное состояние, после чего все вызовы должны завершиться.                              }
     Помимо использования разных синхронизирующих объектов, в этом                       }
примере интересно поведение CLR: асинхронные вызовы должны обраба-                       public int inc() {
тываться в пуле потоков, однако число вызовов превышает число потоков                       m_rwlock.AcquireWriterLock( -1 );
в пуле. CLR по мере необходимости добавляет в пул потоки для обработ-                       try {
ки поступающих запросов.                                                                      m_a++; Thread.Sleep( 500 ); m_b++;
     Потоки не являются наследниками класса WaitHandle в силу того, что                       return m_a + m_b;
для разных базовых платформ потоки могут быть реализованы в качестве                        } finally {
потоков операционной системы или легковесных потоков, управляемых                             m_rwlock.ReleaseWriterLock();
CLR. В последнем случае потоки .NET не будут иметь никаких аналогов                         }
среди объектов ядра операционной системы. Для синхронизации с пото-                      }
ками надо использовать метод Join класса Thread.                                         public static void Invoke( SomeData sd, int no ) {
     Один «писатель», много «читателей»                                                     if ( no % 2 == 0 ) {
     Одной из типичных задач синхронизации потоков является задача, в                         Console.WriteLine( sd.inc() );
которой допускается одновременный конкурентный доступ многих объе-                          } else {
ктов для чтения данных («читатели») и исключительный доступ единст-                           Console.WriteLine( sd.summ() );
венного потока, вносящего в объект изменения («писатель»). В Win32 API                      }
стандартного объекта, реализующего подобную логику, не существует, по-                   }
этому каждый раз его надо проектировать и создавать заново.                             }
     .NET предоставляет весьма эффективное стандартное решение:                         public delegate void AsyncProcCallback(SomeData sd, int no);
класс ReaderWriterLock. В приводимом ниже примере демонстрируется                       class TestApp {
применение методов Acquire... и Release... для корректного использова-                    public static void Main() {
ния блокировки доступа при чтении и записи. Тестовый класс содержит                         int                 i;
две целочисленные переменные, которые считываются и увеличиваются                           SomeData            sd = new SomeData();
на 1 с небольшими задержками по отношению друг к другу. Пока опера-                         WaitHandle[]        wh;
ции синхронизируются, попытка чтения или изменения всегда будет воз-                        AsyncProcCallback apd;
вращать четный результат, а вот если бы синхронизация не выполнялась,                       wh = new WaitHandle[ SomeData.m_queries ];
то в некоторых случаях получались бы нечетные числа:                                        apd = new AsyncProcCallback( SomeData.Invoke );
     using System;                                                                          for ( i = 0; i < SomeData.m_queries; i++ ) wh[i] =
     using System.Threading;                                                                    apd.BeginInvoke(sd,i,null,null).AsyncWaitHandle;
     namespace TestNamespace {                                                              WaitHandle.WaitAll( wh );
        public class SomeData {                                                           }
          public const int           m_queries = 10;                                    }
          private ReaderWriterLock m_rwlock = new ReaderWriterLock();               }