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).
Рис. 14.1. Синхронные вызовы методов "блокируют" другие вызовы
При выполнении этой программы вы заметите, что перед тем выполнением Console.WriteLine() произойдет пятисекундная задержка. И хотя многие методы (если не подавляющее их большинство) могут вызваться синхронно совершенно безболезненно, делегатам .NET, если это необходимо, можно дать указание вызывать методы асинхронно.
Исходный код. Проект SyncDelegate размещен в подкаталоге, соответствующем главе 14.
Асинхронная природа делегатов
Если для вас тема многопоточных приложений является новой, вы можете спросить, чем же на самом деле является асинхронный вызов метода. Вы, без сомнения, знаете о том, что для выполнения некоторых программных операций требуется время. Предыдущий метод Add() был исключительно иллюстративным, но представьте себе, что вы построили однопоточное приложение, в котором вызывается метод удаленного объекта, выполняющий сложный запрос к большой базе данных или запись 500 строк текста во внешний файл. Пока не закончится выполнение этих операций, приложение будет казаться зависшим достаточно долгое время. Пока соответствующая задача не будет обработана, все другие возможности программы (такие как, например, активизация меню, выбор элементов в панели инструментов или вывод на консоль) будут недоступны для пользователя.
Но как дать указание делегату вызвать метод в отдельном потоке выполнения, чтобы имитировать одновременное выполнение множества задач? К счастью, нужной для этого способностью автоматически наделяется каждый тип делегата .NET. И более того, для такого вызова вам не требуется углубляться в детали пространства имен System.Threading (хотя, естественно, одно другому не мешает).
Методы BeginInvoke() и EndInvoke()
Когда компилятор C# обрабатывает ключевое слово delegate, динамически генерируемый класс определяет два метода с именами BeginInvoke() и EndInvoke(). Для нашего определения делегата BinaryOp эти методы оказываются следующими.
sealed class BinaryOp : System.MulticastDelegate {
…
// Используется для асинхронного вызова метода.
public IAsyncResult BeginInvoke(int x, int y, AsyncCallback cb, object state);
// Используется для извлечения возвращаемого значения
// вызванного метода.
public int EndInvoke(IAsyncResult result);
}
Первый набор параметров, передаваемых в BeginInvoke(), формируется на основе формата делегата C# (в случае BinaryOp это два целочисленных значения). Последними двумя аргументами всегда являются System.AsyncCallback и System.Object. Мы рассмотрим роль этих параметров чуть позже, а пока что для каждого из них мы будем использовать null.
Интерфейс System.IAsyncResult
Метод BeginInvoke() всегда возвращает объект, реализующий интерфейс IAsyncResult, а метод EndInvoke() имеет единственный параметр типа IAsyncResult. Совместимый с IAsyncResult объект, возвращаемый методом BeginInvoke(), и является тем связующим механизмом, который позволяет вызывающему потоку получить результат асинхронного вызова метода позже с помощью EndInvoke(). Интерфейс IAsyncResult (определенный в пространстве имен System) задается так, как показано ниже.
public interface IAsyncResult {
object AsyncState { get; }
WaitHandle AsyncWaitHandle { get; }
bool CompletedSynchronously { get; }
bool IsCompleted { get; }
}
В самом простом случае можно избежать непосредственного вызова этих членов. Требуется только сохранить совместимый с IAsyncResult объект, возвращенный BeginInvoke(), и передать его методу EndInvoke(), когда вы будете готовы получить результат вызова метода. Позже вы увидите, что у вас есть возможность вызывать члены совместимого с IAsyncResult объекта, если вы хотите "участвовать" в процессе извлечения возвращаемого значений метода.
Замечание. Если асинхронно вызывается метод, который не предлагает возвращаемых значений, можно его вызвать и престо "забыть" о нем. В таких случаях нет необходимости сохранять совместимый с IAsyncResult объект и вызывать EndInvoke() (так как нет возвращаемого значения, которое требуется извлечь).
Асинхронный вызов методов
Чтобы дать указание делегату BinaryOp вызвать метод Add() асинхронно, измените предыдущий метод Main() так, как показано ниже.
static void Main(string[] args) {
Console.WriteLine("***** асинхронный вызов делегата *****");
// Вывод ID выполняемого потока.
Console.WriteLine("Вызван Main() в потоке {0}.", Thread.CurrentThread.GetHashCode());
// Вызов Add() во вторичном потоке.
BinaryOp b = new BinaryOp(Add);
IAsyncResult iftAR = b.BeginInvoke(10, 10, null, null);
// Выполнение другой работы в первичном потоке.…
Console.WriteLine("В Main() еще есть работа!");
// Получение результата метода Add(),
// когда это требуется.
int answer = b.EndInvoke(iftAR);
Console.WriteLine ("10 + 10 равно {0}.", answer);
Console.ReadLine();
}
Выполнив это приложение, вы увидите, что теперь выводятся два разных хешированных значения, поскольку в границах текущего домена приложения выполняются два потока (см. рис. 14.2).
Рис. 14.2. Методы, вызываемые асинхронно, выполняют свою работу в отдельном потоке
Вдобавок к уникальным хешированным значениям, вы также обнаружите, что при запуске приложения сообщение "В Main() еще есть работа!" появляется практически немедленно.
Синхронизация вызывающего потока
Для текущей реализации Main() диапазон времени между вызовом BeginInvoke() и вызовом EndInvoke() явно меньше пяти секунд. Поэтому после вывода на консоль сообщения "В Main() еще есть работа!" поток вызова блокируется и ждет завершения существования вторичного потока, который должен получить результат метода Add(). Таким образом, вы на самом деле выполняете еще один синхронный вызов.
static void Main (string[] args) {
…
BinaryOp b = new BinaryOp(Add);
IAsyncResult iftAR = b.BeginInvoke(10, 10, null, null);
// До этого вызова проходит менее 5 секунд!
Console.WriteLine("В Main() еще есть работа!");
// Вызывающий поток блокируется до завершения EndInvoke().
int answer = b.EndInvoke(iftAR);
…
}
Очевидно, что асинхронные делегаты теряют свою привлекательность, если поток вызова может при определенных условиях блокироваться. Чтобы позволить вызывающему потоку выяснить, закончил ли асинхронно вызванный метод свою работу, интерфейс IAsyncResult предлагает свойство IsCompleted. Используя этот член, поток вызова может перед вызовом EndInvoke() проверить, завершен ли асинхронный вызов. Если работа метода не завершена, IsCompleted возвращает false (ложь), и поток вызова может продолжать свою работу. Если же IsCompleted возвращает true (истина), то поток вызова может получить результат "наименее блокирующим" способом. Рассмотрите следующую модификацию метода Main().
static void Main (string[] args) {
…
BinaryOp b = new BinaryOp(Add);
IAsyncResult iftAR = b.BeginInvoke(10, 10, null, null);
// Это сообщение будет печататься до тех пор, // пока не завершится вызов метода Add().
while (!iftAR.isCompleted) Console. WriteLine("В Main() еще есть работа!");
// Теперь мы знаем, что вызов метода Add() завершен.
