Добавил:
Upload Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:
Многопоточность.docx
Скачиваний:
0
Добавлен:
01.04.2025
Размер:
113 Кб
Скачать
☆

Класс Task

С появлением .NET Framework 4.0 Microsoft предоставляет нам новые возможности по созданию и управлению многопоточными приложениями. Ряд новых классов для работы с потоками был введен в пространстве имен System.Threading.Tasks (проект Tasks).

Создание потоков

Начнем рассмотрение этого пространства имен с класса Task. Наиболее простым способом создания потока с использованием этого класса является вызов метода StartNew у статического свойства Factory (класс Exercise1):

Task.Factory.StartNew(CheckPrimeNumber);

Свойство Factory возвращает объект класса TaskFactory. Этот объект отвечает за создание объектов типа Task.

У метода StartNew есть много перезагрузок, позволяющих создавать потоки, которые возвращают результаты, потоки, которым передаются параметры и т.д (класс Exercise2):

Task.Factory.StartNew(CheckParameterPrimeNumber, 1000000021);

Ожидание завершения потока

Методы класса TaskFactory, и StartNew в том числе, возвращают объект класса Task. Этот объект предоставляет информацию о потоке. В числе прочих в него входит свойство IsComplete, с помощью которого можно проверить, завершился ли поток (класс Exercise3):

Task task = Task.Factory.StartNew(CheckParameterPrimeNumber, 1000000021);

while (!task.IsCompleted)

{ continue; }

Аналогичного результата можно достичь, вызвав метод Wait (класс Exercise4):

task.Wait();

Как обычно при этом выполнение вызывающего потока приостанавливается до завершения выполнения потока задачи.

Однако данный класс предоставляет и возможность асинхронно дождаться завершения выполнения потока. Эта функциональность аналогична той, что используют делегаты. Для этого используется метод FromAsync класса TaskFactory (класс Exercise5):

Action dlgt = CheckPrimeNumber;

Task.Factory.FromAsync(dlgt.BeginInvoke, GetDividerFinished, null);

Синтаксис этого метода несколько запутан, но все же позволяет осуществить задуманное. После завершения потока будет вызван указанный метод GetDividerFinished. Такой сложный синтаксис обусловлен тем, что данный подход обычно используется для вызова методов асинхронной обработки. Их примерами могут служить методы асинхронного чтения/записи у потоков, методы асинхронной работы с Web-сервисами и ряд других. Обычно такие методы представлены парами BeginXXX/EndXXX. Например, следующий код иллюстрирует, как асинхронно прочитать файл (класс Exercise6):

FileInfo fi = new FileInfo("TextFile1.txt");

byte[] data = new byte[fi.Length];

FileStream fs = File.OpenRead("TextFile1.txt");

Task<int> task = Task<int>.Factory.FromAsync(fs.BeginRead, fs.EndRead, data, 0, data.Length, null);

Однако класс Task предоставляет более простой и мощный способ асинхронно дождаться завершения выполнения потока: присоединение задач. Этот механизм позволяет начать выполение потока после того, как один или несколько потоков завершат свое выполнение. Работает этот механизм с помощью метода ContinueWith (класс Exercise7):

Task task = new Task(CheckPrimeNumber);

task.ContinueWith(GetDividerFinished);

task.Start();

Этому методу передается делегат, ссылающийся на метод, принимающий экземпляр Task в качестве параметра:

private static void GetDividerFinished(Task finished)

Этот метод будет выполнен после того, как закончит свою работу задача. Кроме того, класс TaskFactory имеет методы ContinueWhenAll и ContinueWhenAny, позволяющие выполнить ваш метод после того, как завершатся все задачи из списка, или после того, как завершится любая задача из списка.

Такое выстраивание асинхронных методов в цепочку является в ряде случаев весьма полезным. Рассмотрим следующий пример (класс Exercise8). Пусть наше приложение принимает некоторые данные от Web-сервиса в интернет. Получение данных при этом должно выполняться асинхронно. Кроме того, для сокращения объема передаваемых данных они сжаты, поэтому после получения данные должны быть разжаты. Операция разжатия данных так же должна выполняться асинхронно. Для выполнения данных действий раньше приходилось создавать сложные цепочки делегатов, вызывать методы асинхронного исполнения один из другого. Теперь эта задача решается проще:

private static byte[] CompressedData;

private static string UncompressedResult;

public static void Run()

{

Task task = new Task(GetCompressedDataFromWebService);

task.ContinueWith(UncompressData).ContinueWith(UseUncompressedData);

task.Start();

}

private static void GetCompressedDataFromWebService()

{

// code to get data from Web service.

Console.WriteLine("Data were obtained from Web service.");

}

private static void UncompressData(Task finished)

{

// code to decompress obtained data.

Console.WriteLine("Data were uncompressed.");

}

private static void UseUncompressedData(Task finished)

{

Console.WriteLine("Data from service is '{0}'.", UncompressedResult);

}

Как видите, код вполне прямолинейный. На самом деле отдельные методы в цепочке могут ничего не знать друг о друге. Это несомненное достоинство и упрощение. Метод ContinueWith сам возвращает экземпляр класса Task, что позволяет строить цепочки произвольной длины.