ЯЗЫК ПРОГРАММИРОВАНИЯ С# 2005 И ПЛАТФОРМА .NET 2.0. 3-е издание

Теперь вам должно быть ясно, что домены многопоточного приложения тоже открыты влиянию потоков, поскольку потоки могут пытаться использовать доступные функциональные возможности одновременно. Чтобы защитить ресурсы приложения от возможных искажении, разработчикам .NET приходится использовать так называемые примитивы потоков (такие, как блокировки, мониторы и атрибут [Synchronization]), чтобы контролировать доступ выполняемых потоков.

Нельзя утверждать, что платформа .NET исключила все трудности, возникающие при построении устойчивых многопоточных приложений, но теперь этот процесс значительно упрощён. Используя типы, определенные в пространстве имен System.Threading, вы получаете возможность создавать дополнительные потоки с минимальными усилиями и минимальными проблемами. Точно так же, когда приходит время блокировать открытые элементы данных, вы можете использовать дополнительные типы, которые обеспечивают те же функциональные возможности, что и примитивы потоков Win32 API (но при этом используется намного более аккуратная объектная модель).

Однако использование пространства имея System.Threading – это не единственный путь построения многопоточных программ .NET. В ходе нашего обсуждения делегатов (см. главу 8) мы уже упоминали о том, что все делегаты NET обладают способностью асинхронного вызова членов. Это – главное преимущество платформы .NET, поскольку одной из основных причин, в силу которых разработчик создает потоки, является необходимость такого вызова методов, при котором не возникает блокировок (т.е. именно асинхронного вызова). Для достижения такого результата можно использовать и пространство имен System.Threading, но с помощью делегатов это делается намного проще.

Краткий обзор делегатов .NET

Напомним, что тип делегата .NET – это обеспечивающий типовую безопасность объектно-ориентированный указатель функции. Когда вы объявляете делегат .NET, компилятор C# отвечает на это созданием изолированного класса, полученного из System.MulticastDelegate (который, в свою очередь, является производным от System.Delegate). Эти базовые классы наделяют каждый делегат способностью поддерживать список адресов методов, которые могут быть вызваны позднее. Давайте рассмотрим декларацию делегата BinaryOp, который был впервые определен в главе 8.

// Тип делегата C#.
public delegate int BinaryOp(int x, int y);

В соответствии с данным определением BinaryOp может указывать на любой метод с двумя целочисленными аргументами, возвращающий целочисленное значение. После компиляции соответствующий компоновочный блок будет содержать полноценное определение класса, которое динамически генерируется на основе декларации делегата. В случае BinaryOp это определение класса будет выглядеть приблизительно так (приводится в псевдокоде).

sealed class BinaryOp: System.MulticastDelegate {
 public BinaryOp(object target, uint functionAddress);
 public void Invoke(int x, int y);
 public IAsyncResult BeginInvoke(int x, int y, AsyncCallback cb, object state);
 public int EndInvoke(IAsyncResult result);
}

Напомним, что генерируемый метод Invoke используется для вызова методов, обслуживаемых объектом делегата в синхронном режиме. В этом случае вызывающий поток (например, первичный поток приложения) вынужден ждать, пока не завершится вызов делегата. Также напомним, что в C# метод Invoke не вызывается в программном коде явно, а запускается в фоновом режиме при использовании "нормального синтаксиса" вызова метода. Рассмотрите следующий программный код, в котором статический метод Add вызывается в синхронной (т.е. блокирующей) форме.

// Это требуется для вызова Thread.Sleep.
using System.Threading;
using System;
namespace SyncDelegate {
 public delegate int BinaryOp(int x, int y);
 class Program {
 static void Main(string[] args) {
 Console.WriteLine("***** Синхронный вызов, делегата *****");
 // Вывод ID выполняемого потока.
 Console.WriteLine("Вызван Main в потоке {0}.", Thread.CurrentThread.GetHashCode);
 // Вызов Add в синхронной форме.
 BinaryOp b = new BinaryOp(Add);
 int answer = b(10, 10);
 // Эти строки не будут выполнены до завершения
 // работы метода Add.
 Console.WriteLine("В Main еще есть работа!");
 Console.WriteLine("10 + 10 равно {0}.", answer);
 Console.ReadLine;
 }
 static int Add(int x, int y) {
 // Вывод ID выполняемого потока.
Console.WriteLine("Вызван Add в потоке {0}.", Thread.CurrentThread.GetHashCode);
 // Пауза примерно 5 секунд для
 // имитации длительной операции.
 Thread.Sleep(5000);
 return x + у;
 }
 }
}

Сначала заметим, что в этой программе используется пространство имен System.Threading. В методе Add вызывается статический метод Thread.Sleep, чтобы приостановить вызывающий поток (приблизительно) на пять секунд для имитации задачи, выполнение которой требует много времени. Поскольку метод Add вызывается в синхронной форме, метод Main не напечатает результат операции до тех пор, пока не завершится работа метода Add.

Далее заметим, что метод Main получает доступ к текущему потоку (с помощью Thread.CurrentThread) и печатает его хешированный код. Поскольку этот хешированный код представляет объект в конкретном состоянии, соответствующее значение можно использовать как "грубый" идентификатор потока. Та же логика используется в статическом методе Add. Как и следует ожидать, поскольку вся работа в этом приложении выполняется исключительно первичным потоком, вы увидите одинаковые хешированные значения в консольном выводе программы (рис. 14.1).