Текст книги "C# 4.0: полное руководство"
Автор книги: Герберт Шилдт
Жанр:
Программирование
сообщить о нарушении
Текущая страница: 70 (всего у книги 83 страниц)
В первоначальных версиях среды .NET Framework поток можно было приостановить вызовом метода Thread.Suspend() и возобновить вызовом метода Thread.Resume(). Но теперь оба эти метода считаются устаревшими и не рекомендуются к применению в новом коде. Объясняется это, в частности, тем, что пользоваться методом Suspend() на самом деле небезопасно, так как с его помощью можно приостановить поток, который в настоящий момент удерживает блокировку, что препятствует ее снятию, а следовательно, приводит к взаимоблокировке. Применение обоих методов может стать причиной серьезных осложнений на уровне системы. Поэтому для приостановки и возобновления потока следует использовать другие средства синхронизации, в том числе мьютекс и семафор.
Состояние потока может быть получено из свойства Threadstate, доступного в классе Thread. Ниже приведена общая форма этого свойства.
public ThreadState ThreadState{ get; }
Состояние потока возвращается в виде значения, определенного в перечислении ThreadState. Ниже приведены значения, определенные в этом перечислении.
ThreadState.Aborted
ThreadState.AbortRequested
ThreadState.Background
ThreadState.Running
ThreadState.Stopped
ThreadState.StopRequested
ThreadState.Suspended
ThreadState.SuspendRequested
ThreadState.Unstarted
ThreadState.WaitSleepJoin
Все эти значения не требуют особых пояснений, за исключением одного. Значение ThreadState.WaitsleepJoin обозначает состояние, в которое поток переходит во время ожидания в связи с вызовом метода Wait(), Sleep() или Join().
Как пояснялось в самом начале этой главы, у всякой программы на C# имеется хотя бы один поток исполнения, называемый основным. Этот поток программа получает автоматически, как только начинает выполняться. С основным потоком можно обращаться таким же образом, как и со всеми остальными потоками.
Для доступа к основному потоку необходимо получить объект типа Thread, который ссылается на него. Это делается с помощью свойства CurrentThread, являющегося членом класса Thread. Ниже приведена общая форма этого свойства.
Данное свойство возвращает ссылку на тот поток, в котором оно используется. Поэтому если свойство CurrentThread используется при выполнении кода в основном потоке, то с его помощью можно получить ссылку на основной поток. Имея в своем распоряжении такую ссылку, можно управлять основным потоком так же, как и любым другим потоком.
В приведенном ниже примере программы сначала получается ссылка на основной поток, а затем получаются и устанавливаются имя и приоритет основного потока.
// Продемонстрировать управление основным потоком.
using System;
using System.Threading;
class UseMain {
static void Main() {
Thread Thrd;
// Получить основной поток.
Thrd = Thread.CurrentThread;
// Отобразить имя основного потока,
if(Thrd.Name == null)
Console.WriteLine(«У основного потока нет имени.»);
else
Console.WriteLine("Основной поток называется: " + Thrd.Name);
// Отобразить приоритет основного потока.
Console.WriteLine("Приоритет: " + Thrd.Priority);
Console.WriteLine();
// Установить имя и приоритет.
Console.WriteLine(«Установка имени и приоритета.»);
Thrd.Name = «Основной Поток»;
Thrd.Priority = ThreadPriority.AboveNormal;
Console. WriteLine ("Теперь основной поток называется: " +
Thrd.Name);
Console.WriteLine("Теперь приоритет: " + Thrd.Priority);
}
}
Ниже приведен результат выполнения этой программы.
У основного потока нет имени.
Приоритет: Normal
Установка имени и приоритета.
Теперь основной поток называется: Основной Поток
Теперь приоритет: AboveNormal
Следует, однако, быть очень внимательным, выполняя операции с основным потоком. Так, если добавить в конце метода Main() следующий вызов метода Join():
Thrd.Join();
программа никогда не завершится, поскольку она будет ожидать окончания основного потока!
В версии .NET Framework 4.0 внедрен ряд новых средств многопоточной обработки, которые могут оказаться весьма полезными. Самым важным среди них является новая система отмены. В этой системе поддерживается механизм отмены потока простым, вполне определенным и структурированным способом. В основу этого механизма положено понятие признака отмены, с помощью которого указывается состояние отмены потока. Признаки отмены поддерживаются в классе CancellationTokenSource и в структуре CancellationToken. Система отмены полностью интегрирована в новую библиотеку распараллеливания задач (TPL), и поэтому она подробнее рассматривается вместе с TPL в главе 24.
В класс System.Threading добавлена структура SpinWait, предоставляющая методы SpinOnce() и SpinUntil(), которые обеспечивают более полный контроль над ожиданием в состоянии занятости. Вообще говоря, структура SpinWait оказывается непригодной для однопроцессорных систем. А для многопроцессорных систем она применяется в цикле. Еще одним элементом, связанным с ожиданием в состоянии занятости, является структура SpinLock, которая применяется в цикле ожидания до тех пор, пока не станет доступной блокировка. В класс Thread добавлен метод Yield(), который просто выдает остаток кванта времени, выделенного потоку. Ниже приведена общая форма объявления этого метода.
public static bool Yield()
Этот метод возвращает логическое значение true, если происходит переключение контекста. В отсутствие другого потока, готового для выполнения, переключение контекста не произойдет.
Для эффективного многопоточного программирования самое главное – мыслить категориями параллельного, а не последовательного выполнения кода. Так, если в одной программе имеются две подсистемы, которые могут работать параллельно, их следует организовать в отдельные потоки. Но делать это следует очень внимательно и аккуратно, поскольку если создать слишком много потоков, то тем самым можно значительно снизить,.а не повысить производительность программы. Следует также иметь в виду дополнительные издержки, связанные с переключением контекста. Так, если создать слишком много потоков, то на смену контекста уйдет больше времени ЦП, чем на выполнение самой программы! И наконец, для написания нового кода, предназначенного для многопоточной обработки, рекомендуется пользоваться библиотекой распараллеливания задач (TPL), о которой речь пойдет в следующей главе.
Многозадачность на основе потоков чаще всего организуется при программировании на С#. Но там, где это уместно, можно организовать и многозадачность на основе процессов. В этом случае вместо запуска другого потока в одной и той же программе одна программа начинает выполнение другой. При программировании на C# это делается с помощью класса Process, определенного в пространстве имен System.Diagnostics. В заключение этой главы вкратце будут рассмотрены особенности запуска и управления другим процессом.
Простейший способ запустить другой процесс – воспользоваться методом Start(), определенным в классе Process. Ниже приведена одна из самых простых форм этого метода:
public static Process Start(string имя_файла)
где имя_файла обозначает конкретное имя файла, который должен исполняться или же связан с исполняемым файлом.
Когда созданный процесс завершается, следует вызвать метод Close(), чтобы освободить память, выделенную для этого процесса. Ниже приведена форма объявления метода Close().
public void Close()
Процесс может быть прерван двумя способами. Если процесс является приложением Windows с графическим пользовательским интерфейсом, то для прерывания такого процесса вызывается метод CloseMainWindow(), форма которого приведена ниже.
public bool CloseMainWindow()
Этот метод посылает процессу сообщение, предписывающее ему остановиться. Он возвращает логическое значение true, если сообщение получено, и логическое значение false, если приложение не имеет графического пользовательского интерфейса или главного окна. Следует, однако, иметь в виду, что метод CloseMainWindow() служит только для запроса остановки процесса. Если приложение проигнорирует такой запрос, то оно не будет прервано как процесс.
Для безусловного прерывания процесса следует вызвать метод Kill(), как показано ниже.
public void Kill()
Но методом Kill() следует пользоваться аккуратно, так как он приводит к неконтролируемому прерыванию процесса. Любые несохраненные данные, связанные с прерываемым процессом, будут, скорее всего, потеряны.
Для того чтобы организовать ожидание завершения процесса, можно воспользоваться методом WaitForExit(). Ниже приведены две его формы.
public void WaitForExit()
public bool WaitForExit(int миллисекунд)
В первой форме ожидание продолжается до тех пор, пока процесс не завершится, а во второй форме – только в течение указанного количества миллисекунд. В последнем случае метод WaitForExit() возвращает логическое значение true, если процесс завершился, и логическое значение false, если он все еще выполняется.
В приведенном ниже примере программы демонстрируется создание, ожидание и закрытие процесса. В этой программе сначала запускается стандартная сервисная программа Windows: текстовый редактор WordPad.exe, а затем организуется ожидание завершения программы WordPad как процесса.
// Продемонстрировать запуск нового процесса.
using System;
using System.Diagnostics;
class StartProcess {
static void Main() {
Process newProc = Process.Start(«wordpad.exe»);
Console.WriteLine(«Новый процесс запущен.»);
newProc.WaitForExit();
newProc.Close(); // освободить выделенные ресурсы
Console.WriteLine(«Новый процесс завершен.»);
}
}
При выполнении этой программы запускается стандартное приложение WordPad, и на экране появляется сообщение "Новый процесс запущен. ". Затем программа ожидает закрытия WordPad. По окончании работы WordPad на экране появляется заключительное сообщение «Новый процесс завершен.».
ГЛАВА 24 Многопоточное программирование. Часть вторая: библиотека TPL
Вероятно, самым главным среди новых средств, внедренных в версию 4.0 среды .NET Framework, является библиотека распараллеливания задач (TPL). Эта библиотека усовершенствует многопоточное программирование двумя основными способами. Во-первых, она упрощает создание и применение многих потоков. И во-вторых, она позволяет автоматически использовать несколько процессоров. Иными словами, TPL открывает возможности для автоматического масштабирования приложений с целью эффективного использования ряда доступных процессоров. Благодаря этим двух особенностям библиотеки TPL она рекомендуется в большинстве случаев к применению для организации многопоточной обработки.
Еще одним средством параллельного программирования, внедренным в версию 4.0 среды .NET Framework, является параллельный язык интегрированных запросов (PLINQ). Язык PLINQ дает возможность составлять запросы, для обработки которых автоматически используется несколько процессоров, а также принцип параллелизма, когда это уместно. Как станет ясно из дальнейшего, запросить параллельную обработку запроса очень просто. Следовательно, с помощью PLINQ можно без особого труда внедрить параллелизм в запрос.
Главной причиной появления таких важных новшеств, как TPL и PLINQ, служит возросшее значение параллелизма в современном программировании. В настоящее время многоядерные процессоры уже стали обычным явлением.
Кроме того, постоянно растет потребность в повышении производительности программ. Все это, в свою очередь, вызвало растущую потребность в механизме, который позволял бы с выгодой использовать несколько процессов для повышения производительности программного обеспечения. Но дело в том, что в прошлом это было не так-то просто сделать ясным и допускающим масштабирование способом. Изменить это положение, собственно, и призваны TPL и PLINQ. Ведь они дают возможность легче (и безопаснее) использовать системные ресурсы.
Библиотека TPL определена в пространстве имен System.Threading.Tasks. Но для работы с ней обычно требуется также включать в программу класс System.Threading, поскольку он поддерживает синхронизацию и другие средства многопоточной обработки, в том числе и те, что входят в класс Interlocked.
В этой главе рассматривается и TPL, и PLINQ. Следует, однако, иметь в виду, что и та и другая тема довольно обширны. Поэтому в этой главе даются самые основы и рассматриваются некоторые простейшие способы применения TPL и PLINQ. Таким образом, материал этой главы послужит вам в качестве удобной отправной точки для дальнейшего изучения TPL и PLINQ. Если параллельное программирование входит в сферу ваших интересов, то именно эти средства .NET Framework вам придется изучить более основательно.
–
ПРИМЕЧАНИЕ
Несмотря на то что применение TPL и PLINQ рекомендуется теперь для разработки большинства многопоточных приложений, организация многопоточной обработки на основе класса Thread, представленного в главе 23, по-прежнему находит широкое распространение. Кроме того, многое из того, что пояснялось в главе 23, применимо и к TPL. Поэтому усвоение материала главы 23 все еще необходимо для полного овладения особенностями организации многопоточной обработки на С#.
–
Применяя TPL, параллелизм в программу можно ввести двумя основными способами. Первый из них называется параллелизмом данных. При таком подходе одна операция над совокупностью данных разбивается на два параллельно выполняемых потока или больше, в каждом из которых обрабатывается часть данных. Так, если изменяется каждый элемент массива, то, применяя параллелизм данных, можно организовать параллельную обработку разных областей массива в двух или больше потоках. Нетрудно догадаться, что такие параллельно выполняющиеся действия могут привести к значительному ускорению обработки данных по сравнению с последовательным подходом. Несмотря на то что параллелизм данных был всегда возможен и с помощью класса Thread, построение масштабируемых решений средствами этого класса требовало немало усилий и времени. Это положение изменилось с появлением библиотеки TPL, с помощью которой масштабируемый параллелизм данных без особого труда вводится в программу.
Второй способ ввода параллелизм называется параллелизмом задач. При таком подходе две операции или больше выполняются параллельно. Следовательно, параллелизм задач представляет собой разновидность параллелизма, который достигался в прошлом средствами класса Thread. А к преимуществам, которые сулит применение TPL, относится простота применения и возможность автоматически масштабировать исполнение кода на несколько процессоров.
В основу TPL положен класс Task. Элементарная единица исполнения инкапсулируется в TPL средствами класса Task, а не Thread. Класс Task отличается от класса Thread тем, что он является абстракцией, представляющей асинхронную операцию. А в классе Thread инкапсулируется поток исполнения. Разумеется, на системном уровне поток по-прежнему остается элементарной единицей исполнения, которую можно планировать средствами операционной системы. Но соответствие экземпляра объекта класса Task и потока исполнения не обязательно оказывается взаимно-однозначным. Кроме того, исполнением задач управляет планировщик задач, который работает с пулом потоков. Это, например, означает, что несколько задач могут разделять один и тот же поток. Класс Task (и вся остальная библиотека TPL) определены в пространстве имен System.Threading.Tasks.
Создание задачи
Создать новую задачу в виде объекта класса Task и начать ее исполнение можно самыми разными способами. Для начала создадим объект типа Task с помощью конструктора и запустим его, вызвав метод Start(). Для этой цели в классе Task определено несколько конструкторов. Ниже приведен тот конструктор, которым мы собираемся воспользоваться:
public Task(Action действие)
где действие обозначает точку входа в код, представляющий задачу, тогда как Action – делегат, определенный в пространстве имен System. Форма делегата Action, которой мы собираемся воспользоваться, выглядит следующим образом.
public delegate void Action()
Таким образом, точкой входа должен служить метод, не принимающий никаких параметров и не возвращающий никаких значений. (Как будет показано далее, делегату Action можно также передать аргумент.)
Как только задача будет создана, ее можно запустить на исполнение, вызвав метод Start(). Ниже приведена одна из его форм.
public void Start()
После вызова метода Start() планировщик задач запланирует исполнение задачи. В приведенной ниже программе все изложенное выше демонстрируется на практике. В этой программе отдельная задача создается на основе метода MyTask(). После того как начнет выполняться метод Main(), задача фактически создается и запускается на исполнение. Оба метода MyTask() и Main() выполняются параллельно.
// Создать и запустить задачу на исполнение.
using System;
using System.Threading;
using System.Threading.Tasks;
class DemoTask {
static void MyTask() {
Console.WriteLine(«MyTask() запущен»);
for(int count = 0; count < 10; count++) {
Thread.Sleep(500);
Console.WriteLine("В методе MyTask(), подсчет равен " + count);
}
Console.WriteLine(«MyTask завершен»);
}
static void Main() {
Console.WriteLine(«Основной поток запущен.»);
// Сконструировать объект задачи.
Task tsk = new Task(MyTask);
// Запустить задачу на исполнение,
tsk.Start();
// метод Main() активным до завершения метода MyTask().
for(int i = 0; i < 60; i++) {
Console.Write(".");
Thread.Sleep(100);
}
Console.WriteLine(«Основной поток завершен.»);
}
}
Ниже приведен результат выполнения этой программы. (У вас он может несколько отличаться в зависимости от загрузки задач, операционной системы и прочих факторов.)
Основной поток запущен.
.MyTask() запущен
....В методе MyTask(), подсчет равен 0
.....В методе MyTask(), подсчет равен 1
.....В методе MyTask(), подсчет равен 2
....В методе MyTask(), подсчет равен 3
.....В методе MyTask(), подсчет равен 4
.....В методе MyTask(), подсчет равен 5
....В методе MyTask(), подсчет равен 6
.....В методе MyTask(), подсчет равен 7
.....В методе MyTask(), подсчет равен 8
.....В методе MyTask(), подсчет равен 9
MyTask завершен
............Основной поток завершен.
Следует иметь в виду, что по умолчанию задача исполняется в фоновом потоке. Следовательно, при завершении создающего потока завершается и сама задача. Именно поэтому в рассматриваемой здесь программе метод Thread.Sleep() использован для сохранения активным основного потока до тех пор, пока не завершится выполнение метода MyTask(). Как и следовало ожидать, организовать ожидание завершения задачи можно и более совершенными способами, что и будет показано далее.
В приведенном выше примере программы задача, предназначавшаяся для параллельного исполнения, обозначалась в виде статического метода. Но такое требование к задаче не является обязательным. Например, в приведенной ниже программе, которая является переработанным вариантом предыдущей, метод MyTask(), выполняющий роль задачи, инкапсулирован внутри класса.
// Использовать метод экземпляра в качестве задачи.
using System;
using System.Threading;
using System.Threading.Tasks;
class MyClass {
// Метод выполняемый в качестве задачи,
public void MyTask() {
Console.WriteLine(«MyTask() запущен»);
for(int count = 0; count < 10; count++) {
Thread.Sleep(500);
Console.WriteLine("В методе MyTask(), подсчет равен " + count);
}
Console.WriteLine("MyTask завершен ");
}
}
class DemoTask {
static void Main() {
Console.WriteLine(«Основной поток запущен.»);
// Сконструировать объект типа MyClass.
MyClass me = new MyClass();
// Сконструировать объект задачи для метода mc.MyTask().
Task tsk = new Task(me.MyTask);
// Запустить задачу на исполнение,
tsk.Start();
// Сохранить метод Main() активным до завершения метода MyTask().
for(int i = 0; i < 60; i++) {
Console.Write (".");
Thread.Sleep (100);
}
Console.WriteLine(«Основной поток завершен.»);
}
}
Результат выполнения этой программы получается таким же, как и прежде. Единственное отличие состоит в том, что метод MyTask() вызывается теперь для экземпляра объекта класса MyClass.
В отношении задач необходимо также иметь в виду следующее: после того, как задача завершена, она не может быть перезапущена. Следовательно, иного способа повторного запуска задачи на исполнение, кроме создания ее снова, не существует.
Применение идентификатора задачи
В отличие от класса Thread; в классе Task отсутствует свойство Name для хранения имени задачи. Но вместо этого в нем имеется свойство Id для хранения идентификатора задачи, по которому можно распознавать задачи. Свойство Id доступно только для чтения и относится к типу int. Оно объявляется следующим образом.
public int Id { get; }
Каждая задача получает идентификатор, когда она создается. Значения идентификаторов уникальны, но не упорядочены. Поэтому один идентификатор задачи может появиться перед другим, хотя он может и не иметь меньшее значение.
Идентификатор исполняемой в настоящий момент задачи можно выявить с помощью свойства CurrentId. Это свойство доступно только для чтения, относится к типу static и объявляется следующим образом.
public static Nullable
Оно возвращает исполняемую в настоящий момент задачу или же пустое значение, если вызывающий код не является задачей.
В приведенном ниже примере программы создаются две задачи и показывается, какая из них исполняется.
// Продемонстрировать применение свойств Id и CurrentId.
using System;
using System.Threading;
using System.Threading.Tasks;
class DemoTask {
// Метод, исполняемый как задача,
static void MyTask() {
Console.WriteLine(«MyTask() №» + Task.CurrentId + « запущен»);
for (int count = 0; count < 10; count++) {
Thread.Sleep(500);
Console.WriteLine(«В методе MyTaskO #» + Task.CurrentId +
", подсчет равен " + count );
}
Console.WriteLine(«MyTask №» + Task.CurrentId + « завершен»);
}
static void Main() {
Console.WriteLine(«Основной поток запущен.»);
// Сконструировать объекты двух задач.
Task tsk = new Task(MyTask);
Task tsk2 = new Task(MyTask);
// Запустить задачи на исполнение,
tsk.Start();
tsk2.Start();
Console.WriteLine("Идентификатор задачи tsk: " + tsk.Id);
Console.WriteLine("Идентификатор задачи tsk2: " + tsk2.Id);
// Сохранить метод Main() активным до завершения остальных задач,
for(int i = 0; i < 60; i++) {
Console.Write(".");
Thread.Sleep (100);
}
Console.WriteLine(«Основной поток завершен.»);
}
}
Выполнение этой программы приводит к следующему результату.
Основной поток запущен.
Идентификатор задачи tsk: 1
Идентификатор задачи tsk2: 2
.MyTask() №1 запущен
MyTask() №2 запущен
....В методе MyTask() #1, подсчет равен 0
В методе MyTask() #2, подсчет равен 0
.....В методе MyTask() #1, подсчет равен 1
В методе MyTask() #2, подсчет равен 1
.....В методе MyTask() #1, подсчет равен 2
В методе MyTask() #2, подсчет равен 2
....В методе MyTask() #2, подсчет равен 3
В методе MyTask() #1, подсчет равен 3
.....В методе MyTask() #1, подсчет равен 4
В методе MyTask() #2, подсчет равен 4
.....В методе MyTask() #1, подсчет равен 5
В методе MyTask() #2, подсчет равен 5
.....В методе MyTask() #1, подсчет равен 6
В методе MyTask() #2, подсчет равен 6
....В методе MyTask() #1, подсчет равен 7
В методе MyTask() #2, подсчет равен 7
.....В методе MyTask() #1, подсчет равен 8
В методе MyTask() #2, подсчет равен 8
.....В методе MyTask() #2, подсчет равен 9
MyTask №2 завершен
В методе MyTask() #1, подсчет равен 9
MyTask №1 завершен
............Основной поток завершен.
