Читать книгу 📗 "Полное руководство. С# 4.0 - Шилдт Герберт"

Различают две разновидности многозадачности: на основе процессов и на основепотоков. В связи с этим важно понимать отличия между ними. Процесс фактическипредставляет собой исполняемую программу. Поэтому многозадачность на основе процессов — это средство, благодаря которому на компьютере могут параллельно выполняться две программы и более. Так, многозадачность на основе процессов позволяетодновременно выполнять программы текстового редактора, электронных таблиц ипросмотра содержимого в Интернете. При организации многозадачности на основепроцессов программа является наименьшей единицей кода, выполнение которой может координировать планировщик задач.Поток представляет собой координируемую единицу исполняемого кода. Своимпроисхождением этот термин обязан понятию "поток исполнения". При организациимногозадачности на основе потоков у каждого процесса должен быть по крайней мереодин поток, хотя их может быть и больше. Это означает, что в одной программе одновременно могут решаться две задачи и больше. Например, текст может форматироваться в редакторе текста одновременно с его выводом на печать, при условии, что обаэти действия выполняются в двух отдельных потоках.Отличия в многозадачности на основе процессов и потоков могут быть сведены кследующему: многозадачность на основе процессов организуется для параллельноговыполнения программ, а многозадачность на основе потоков — для параллельного выполнения отдельных частей одной программы.Главное преимущество многопоточной обработки заключается в том, что она позволяет писать программы, которые работают очень эффективно благодаря возможности выгодно использовать время простоя, неизбежно возникающее в ходе выполнениябольшинства программ. Как известно, большинство устройств ввода-вывода, будь тоустройства, подключенные к сетевым портам, накопители на дисках или клавиатура,работают намного медленнее, чем центральный процессор (ЦП). Поэтому большуючасть своего времени программе приходится ожидать отправки данных на устройствоввода-вывода или приема информации из него. А благодаря многопоточной обработке программа может решать какую-нибудь другую задачу во время вынужденного простоя. Например, в то время как одна часть программы отправляет файл черезсоединение с Интернетом, другая ее часть может выполнять чтение текстовой информации, вводимой с клавиатуры, а третья — осуществлять буферизацию очередногоблока отправляемых данных.Поток может находиться в одном из нескольких состояний. В целом, поток можетбыть выполняющимся; готовым к выполнению, как только он получит время и ресурсыЦП; приостановленным, т:е. временно не выполняющимся; возобновленным в дальнейшем; заблокированным в ожидании ресурсов для своего выполнения; а также завершенным, когда его выполнение окончено и не может быть возобновлено.В среде .NET Framework определены две разновидности потоков: приоритетныйи фоновый. По умолчанию создаваемый поток автоматически становится приоритетным, но его можно сделать фоновым. Единственное отличие приоритетных потоков отфоновых заключается в том, что фоновый поток автоматически завершается, если в егопроцессе остановлены все приоритетные потоки.В связи с организацией многозадачности на основе потоков возникает потребностьв особого рода режиме, который называется синхронизацией и позволяет координировать выполнение потоков вполне определенным образом. Для такой синхронизациив C# предусмотрена отдельная подсистема, основные средства которой рассматриваются в этой главе.Все процессы состоят хотя бы из одного потока, который обычно называют основным, поскольку именно с него начинается выполнение программы. Следовательно,в основном потоке выполнялись все приведенные ранее примеры программ. Из основного потока можно создать другие потоки.В языке C# и среде .NET Framework поддерживаются обе разновидности многозадачности: на основе процессов и на основе потоков. Поэтому средствами C# можносоздавать как процессы, так и потоки, а также управлять и теми и другими. Длятого чтобы начать новый процесс, от программирующего требуется совсем немного усилий, поскольку каждый предыдущий процесс совершенно обособлен от последующего. Намного более важной оказывается поддержка в C# многопоточнойобработки, благодаря которой упрощается написание высокопроизводительных,многопоточных программ на C# по сравнению с некоторыми другими языками программирования.Классы, поддерживающие многопоточное программирование, определены в пространстве имен System.Threading. Поэтому любая многопоточная программа на C#включает в себя следующую строку кода.using System.Threading;Класс ThreadСистема многопоточной обработки основывается на классе Thread, который инкапсулирует поток исполнения. Класс Thread является герметичным, т.е. он не можетнаследоваться. В классе Thread определен ряд методов и свойств, предназначенныхдля управления потоками. На протяжении всей этой главы будут рассмотрены наиболее часто используемые члены данного класса.Создание и запуск потокаДля создания потока достаточно получить экземпляр объекта типа Thread,т.е. класса, определенного в пространстве имен System.Threading. Ниже приведенапростейшая форма конструктора класса Thread:public Thread(ThreadStart запуск)где запуск — это имя метода, вызываемого с целью начать выполнение потока,a ThreadStart — делегат, определенный в среде .NET Framework, как показанониже.public delegate void ThreadStart()Следовательно, метод, указываемый в качестве точки входа в поток, должен иметьвозвращаемый тип void и не принимать никаких аргументов.Вновь созданный новый поток не начнет выполняться до тех пор, пока не будетвызван его метод Start(), определяемый в классе Thread. Существуют две формыобъявления метода Start(). Ниже приведена одна из них.public void Start()Однажды начавшись, поток будет выполняться до тех пор, пока не произойдетвозврат из метода, на который указывает запуск. Таким образом, после возврата изэтого метода поток автоматически прекращается. Если же попытаться вызвать методStart() для потока, который уже начался, это приведет к генерированию исключения ThreadStateException.В приведенном ниже примере программы создается и начинает выполняться новый поток.// Создать поток исполнения.using System;using System.Threading;class MyThread {public int Count;string thrdName;public MyThread(string name) {Count = 0;thrdName = name;}// Точка входа в поток.public void Run() {Console.WriteLine(thrdName + " начат.");do {Thread.Sleep(500);Console.WriteLine("В потоке " + thrdName + ", Count = " + Count);Count++;} while(Count < 10);Console.WriteLine(thrdName + " завершен.");}}class MultiThread {static void Main() {Console.WriteLine("Основной поток начат.");// Сначала сконструировать объект типа MyThread.MyThread mt = new MyThread("Потомок #1");// Далее сконструировать поток из этого объекта.Thread newThrd = new Thread(mt.Run);// И наконец, начать выполнение потока.newThrd.Start();do {Console.Write(".");Thread.Sleep(100);} while (mt.Count != 10);Console.WriteLine("Основной поток завершен.");}}Рассмотрим приведенную выше программу более подробно. В самом ее началеопределяется класс MyThread, предназначенный для создания второго потока исполнения. В методе Run() этого класса организуется цикл для подсчета от 0 до 9. Обратите внимание на вызов статического метода Sleep(), определенного в классе Thread.Этот метод обусловливает приостановление того потока, из которого он был вызван,на определенный период времени, указываемый в миллисекундах. Когда приостанавливается один поток, может выполняться другой. В данной программе используетсяследующая форма метода Sleep():public static void Sleep(int миллисекундпростоя)где миллисекундпростоя обозначает период времени, на который приостанавливается выполнение потока. Если указанное количество миллисекундпростоя равнонулю, то вызывающий поток приостанавливается лишь для того, чтобы предоставитьвозможность для выполнения потока, ожидающего своей очереди.В методе Main() новый объект типа Thread создается с помощью приведеннойниже последовательности операторов.// Сначала сконструировать объект типа MyThread.MyThread mt = new MyThread("Потомок #1");// Далее сконструировать поток из этого объекта.Thread newThrd = new Thread(mt.Run);// И наконец, начать выполнение потока.newThrd.Start();Как следует из комментариев к приведенному выше фрагменту кода, сначала создается объект типа MyThread. Затем этот объект используется для создания объектатипа Thread, для чего конструктору этого объекта в качестве точки входа передаетсяметод mt.Run(). И наконец, выполнение потока начинается с вызова метода Start().Благодаря этому метод mt.Run() выполняется в своем собственном потоке. После вызова метода Start() выполнение основного потока возвращается к методу Main(),где начинается цикл do-while. Оба потока продолжают выполняться, совместно используя ЦП, вплоть до окончания цикла. Ниже приведен результат выполнения данной программы. (Он может отличаться в зависимости от среды выполнения, операционной системы и степени загрузки задач.)Основной поток начат.Потомок #1 начат.....В потоке Потомок #1, Count = 0....В потоке Потомок #1, Count = 1....В потоке Потомок #1, Count = 2....В потоке Потомок #1, Count = 3....В потоке Потомок #1, Count = 4....В потоке Потомок #1, Count = 5....В потоке Потомок #1, Count = 6....В потоке Потомок #1, Count = 7....В потоке Потомок #1, Count = 8....В потоке Потомок #1, Count = 9Потомок #1 завершен.Основной поток завершен.Зачастую в многопоточной программе требуется, чтобы основной поток был последним потоком, завершающим ее выполнение. Формально программа продолжаетвыполняться до тех пор, пока не завершатся все ее приоритетные потоки. Поэтомутребовать, чтобы основной поток завершал выполнение программы, совсем не обязательно. Тем не менее этого правила принято придерживаться в многопоточномпрограммировании, поскольку оно явно определяет конечную точку программы.В рассмотренной выше программе предпринята попытка сделать основной потокзавершающим ее выполнение. Для этой цели значение переменной Count проверяется в цикле do-while внутри метода Main(), и как только это значение оказываетсяравным 10, цикл завершается и происходит поочередный возврат из методов Sleep().Но такой подход далек от совершенства, поэтому далее в этой главе будут представлены более совершенные способы организации ожидания одного потока до завершениядругого.Простые способы усовершенствования многопоточной программыРассмотренная выше программа вполне работоспособна, но ее можно сделать более эффективной, внеся ряд простых усовершенствований. Во-первых, можно сделатьтак, чтобы выполнение потока начиналось сразу же после его создания. Для этого достаточно получить экземпляр объекта типа Thread в конструкторе класса MyThread.И во-вторых, в классе MyThread совсем не обязательно хранить имя потока, посколькудля этой цели в классе Thread специально определено свойство Name.public string Name { get; set; }Свойство Name доступно для записи и чтения и поэтому может сложить как длязапоминания, так и для считывания имени потока.Ниже приведена версия предыдущей программы, в которую внесены упомянутыевыше усовершенствования.// Другой способ запуска потока.using System;using System.Threading;class MyThread {public int Count;public Thread Thrd;public MyThread(string name) {Count = 0;Thrd = new Thread(this.Run);Thrd.Name = name; // задать имя потокаThrd.Start(); // начать поток}// Точка входа в поток.void Run() {Console.WriteLine(Thrd.Name + " начат.");do {Thread.Sleep(500);Console.WriteLine("В потоке " + Thrd.Name + ", Count = " + Count);Count++;} while(Count < 10);Console.WriteLine(Thrd.Name + " завершен.");}}class MultiThreadImproved {static void Main() {Console.WriteLine("Основной поток начат.");// Сначала сконструировать объект типа MyThread.MyThread mt = new MyThread("Потомок #1");do {Console.Write(".");Thread.Sleep(100);} while (mt.Count != 10);Console.WriteLine("Основной поток завершен.");}}Эта версия программы дает такой же результат, как и предыдущая. Обратите внимание на то, что объект потока сохраняется в переменной Thrd из класса MyThread.Создание нескольких потоковВ предыдущих примерах программ был создан лишь один порожденный поток.Но в программе можно породить столько потоков, сколько потребуется. Например,в следующей программе создаются три порожденных потока.// Создать несколько потоков исполнения.using System;using System.Threading;class MyThread {public int Count;public Thread Thrd;public MyThread(string name) {Count = 0;Thrd = new Thread(this.Run);Thrd.Name = name;Thrd.Start();}// Точка входа в поток.void Run() {Console.WriteLine(Thrd.Name + " начат.");do {Thread.Sleep(500);Console.WriteLine("В потоке " + Thrd.Name + ", Count = " + Count);Count++;} while(Count < 10);Console.WriteLine(Thrd.Name + " завершен.");}}class MoreThreads {static void Main() {Console.WriteLine("Основной поток начат.");// Сконструировать три потока.MyThread mt1 = new MyThread("Потомок #1");MyThread mt2 = new MyThread("Потомок #2") ;MyThread mt3 = new MyThread("Потомок #3");do {Console.Write(".");Thread.Sleep(100);} while(mt1.Count < 10 ||mt2.Count < 10 ||mt3.Count < 10);Console.WriteLine("Основной поток завершен.");}}Ниже приведен один из возможных результатов выполнения этой программыОсновной поток начат..Потомок #1 начат.Потомок #2 начат.Потомок #3 начат.....В потоке Потомок #1, Count = 0В потоке Потомок #2, Count = 0В потоке Потомок #3, Count = 0.....В потоке Потомок #1, Count = 1В потоке Потомок #2, Count = 1В потоке Потомок #3, Count = 1.....В потоке Потомок #1, Count = 2В потоке Потомок #2, Count = 2В потоке Потомок #3, Count = 2.....В потоке Потомок #1, Count = 3В потоке Потомок #2, Count = 3В потоке Потомок #3, Count = 3.....В потоке Потомок #1, Count = 4В потоке Потомок #2, Count = 4В потоке Потомок #3, Count = 4.....В потоке Потомок #1, Count = 5В потоке Потомок #2, Count = 5В потоке Потомок #3, Count = 5.....В потоке Потомок #1, Count = 6В потоке Потомок #2, Count = 6В потоке Потомок #3, Count = 6.....В потоке Потомок #1, Count = 7В потоке Потомок #2, Count = 7В потоке Потомок #3, Count = 7.....В потоке Потомок #1, Count = 8В потоке Потомок #2, Count = 8В потоке Потомок #3, Count = 8.....В потоке Потомок #1, Count = 9Поток #1 завершен.В потоке Потомок #2, Count = 9Поток #2 завершен.В потоке Потомок #3, Count = 9Поток #3 завершен.Основной поток завершен.Как видите, после того как все три потока начнут выполняться, они будут совместноиспользовать ЦП. Приведенный выше результат может отличаться в зависимости отсреды выполнения, операционной системы и других внешних факторов, влияющих навыполнение программы.Определение момента окончания потокаНередко оказывается полезно знать, когда именно завершается поток. В предыдущих примерах программ для этой цели отслеживалось значение переменной Count.Но ведь это далеко не лучшее и не совсем пригодное для обобщения решение. Правда,в классе Thread имеются два других средства для определения момента окончанияпотока. С этой целью можно, прежде всего, опросить доступное только для чтениясвойство IsAlive, определяемое следующим образом.public bool IsAlive { get; }Свойство IsAlive возвращает логическое значение true, если поток, для которого оно вызывается, по-прежнему выполняется. Для "опробования" свойства IsAliveподставьте приведенный ниже фрагмент кода вместо кода в классе MoreThread изпредыдущей версии многопоточной программы, как показано ниже.// Использовать свойство IsAlive для отслеживания момента окончания потоков.class MoreThreads {static void Main() {Console.WriteLine("Основной поток начат.");// Сконструировать три потока.MyThread mt1 = new MyThread("Поток #1");MyThread mt2 = new MyThread("Поток #2");MyThread mt3 = new MyThread("Поток #3");do {Console.Write(".");Thread.Sleep(100);} while(mt1.Thrd.IsAlive &&mt2.Thrd.IsAlive &&mt3.Thrd.IsAlive);Console.WriteLine("Основной поток завершен.");}}При выполнении этой версии программы результат получается таким же, каки прежде. Единственное отличие заключается в том, что в ней используется свойствоIsAlive для отслеживания момента окончания порожденных потоков.Еще один способ отслеживания момента окончания состоит в вызове методаJoin(). Ниже приведена его простейшая форма.public void Join()Метод Join() ожидает до тех пор, пока поток, для которого он был вызван, незавершится. Его имя отражает принцип ожидания до тех пор, пока вызывающий поток не присоединится к вызванному методу. Если же данный поток не был начат, тогенерируется исключение ThreadStateException. В других формах метода Join()можно указать максимальный период времени, в течение которого следует ожидатьзавершения указанного потока.В приведенном ниже примере программы метод Join() используется для того,чтобы основной поток завершился последним.// Использовать метод Join().using System;using System.Threading;class MyThread {public int Count;public Thread Thrd;public MyThread(string name) {Count = 0;Thrd = new Thread(this.Run);Thrd.Name = name;Thrd.Start();}// Точка входа в поток.void Run() {Console.WriteLine(Thrd.Name + " начат.");do {Thread.Sleep(500);Console.WriteLine("В потоке " + Thrd.Name + ", Count = " + Count);Count++;} While(Count < 10);Console.WriteLine(Thrd.Name + " завершен.");}}// Использовать метод Join() для ожидания до тех пор,// пока потоки не завершатся.class JoinThreads {static void Main() {Console.WriteLine("Основной поток начат.");// Сконструировать три потока.MyThread mt1 = new MyThread("Потомок #1");MyThread mt2 = new MyThread("Потомок #2");MyThread mt3 = new MyThread("Потомок #3");mt1.Thrd.Join();Console.WriteLine("Потомок #1 присоединен.");mt2.Thrd.Join();Console.WriteLine("Потомок #2 присоединен.");mt3.Thrd.Join();Console.WriteLine("Потомок #3 присоединен.");Console.WriteLine("Основной поток завершен.");}}Ниже приведен один из возможных результатов выполнения этой программы. Напомним, что он может отличаться в зависимости от среды выполнения, операционнойсистемы и прочих факторов, влияющих на выполнение программы.Основной поток начат.Потомок #1 начат.Потомок #2 начат.Потомок #3 начат.В потоке Потомок #1, Count = 0В потоке Потомок #2, Count = 0В потоке Потомок #3, Count = 0В потоке Потомок #1, Count = 1В потоке Потомок #2, Count = 1В потоке Потомок #3, Count = 1В потоке Потомок #1, Count = 2В потоке Потомок #2, Count = 2В потоке Потомок #3, Count = 2В потоке Потомок #1, Count = 3В потоке Потомок #2, Count = 3В потоке Потомок #3, Count = 3В потоке Потомок #1, Count = 4В потоке Потомок #2, Count = 4В потоке Потомок #3, Count = 4В потоке Потомок #1, Count = 5В потоке Потомок #2, Count = 5В потоке Потомок #3, Count = 5В потоке Потомок #1, Count = 6В потоке Потомок #2, Count = 6В потоке Потомок #3, Count = 6В потоке Потомок #1, Count = 7В потоке Потомок #2, Count = 7В потоке Потомок #3, Count = 7В потоке Потомок #1, Count = 8В потоке Потомок #2, Count = 8В потоке Потомок #3, Count = 8В потоке Потомок #1, Count = 9Потомок #1 завершен.В потоке Потомок #2, Count = 9Потомок #2 завершен.В потоке Потомок #3, Count = 9Потомок #3 завершен.Потомок #1 присоединен.Потомок #2 присоединен.Потомок #3 присоединен.Основной поток завершен.Как видите, выполнение потоков завершилось после возврата из последовательногоряда вызовов метода Join().Передача аргумента потокуПервоначально в среде .NET Framework нельзя было передавать аргумент потоку,когда он начинался, поскольку у метода, служившего в качестве точки входа в поток, немогло быть параметров. Если же потоку требовалось передать какую-то информацию,то к этой цели приходилось идти различными обходными путями, например использовать общую переменную. Но этот недостаток был впоследствии устранен, и теперьаргумент может быть передан потоку. Для этого придется воспользоваться другимиформами метода Start(), конструктора класса Thread, а также метода, служащего вкачестве точки входа в поток.Аргумент передается потоку в следующей форме метода Start().public void Start(object параметр)Объект, указываемый в качестве аргумента параметр, автоматически передаетсяметоду, выполняющему роль точки входа в поток. Следовательно, для того чтобы передать аргумент потоку, достаточно передать его методу Start().Для применения параметризированной формы метода Start() потребуется следующая форма конструктора класса Thread:public Thread(ParameterizedThreadStart запуск)где запуск обозначает метод, вызываемый с целью начать выполнение потока. Обратите внимание на то, что в этой форме конструктора запуск имеет типParameterizedThreadStart, а не ThreadStart, как в форме, использовавшейсяв предыдущих примерах. В данном случае ParameterizedThreadStart является делегатом, объявляемым следующим образом.public delegate void ParameterizedThreadStart(object obj)Как видите, этот делегат принимает аргумент типа object. Поэтому для правильного применения данной формы конструктора класса Thread у метода, служащегов качестве точки входа в поток, должен быть параметр типа object.В приведенном ниже примере программы демонстрируется передача аргументапотоку.// Пример передачи аргумента методу потока.using System;using System.Threading;class MyThread {public int Count;public Thread Thrd;// Обратите внимание на то, что конструктору класса// MyThread передается также значение типа int.public MyThread(string name, int num) {Count = 0;// Вызвать конструктор типа ParameterizedThreadStart// явным образом только ради наглядности примера.Thrd = new Thread(this.Run);Thrd.Name = name;// Здесь переменная num передается методу Start()// в качестве аргумента.Thrd.Start(num);}// Обратите внимание на то, что в этой форме метода Run()// указывается параметр типа object.void Run(object num) {Console.WriteLine(Thrd.Name + " начат со счета " + num);do {Thread.Sleep(500);Console.WriteLine("В потоке " + Thrd.Name + ", Count = " + Count);Count++;} while(Count < (int) num);Console.WriteLine(Thrd.Name + " завершен.");}}class PassArgDemo {static void Main() {// Обратите внимание на то, что число повторений// передается этим двум объектам типа MyThread.MyThread mt = new MyThread("Потомок #1", 5);MyThread mt2 = new MyThread("Потомок #2", 3);do {Thread.Sleep(100);} while (mt.Thrd.IsAlive'| mt2.Thrd.IsAlive);Console.WriteLine("Основной поток завершен.");}}Ниже приведен результат выполнения данной программы, хотя у вас он может оказаться несколько иным.Потомок #1 начат со счета 5Потомок #2 начат со счета 3В потоке Потомок #2, Count = 0В потоке Потомок #1, Count = 0В потоке Потомок #1, Count = 1В потоке Потомок #2, Count = 1В потоке Потомок #2, Count = 2Потомок #2 завершен.В потоке Потомок #1, Count = 2В потоке Потомок #1, Count = 3В потоке Потомок #1, Count = 4Потомок #1 завершен.Основной поток завершен.Как следует из приведенного выше результата, первый поток повторяется пять раз,а второй — три раза. Число повторений указывается в конструкторе класса MyThreadи затем передается методу Run(), служащему в качестве точки входа в поток, с помощью параметризированной формы ParameterizedThreadStart метода Start().Свойство IsBackgroundКак упоминалось выше, в среде .NET Framework определены две разновидностипотоков: приоритетный и фоновый. Единственное отличие между ними заключаетсяв том, что процесс не завершится до тех пор, пока не окончится приоритетный поток,тогда как фоновые потоки завершаются автоматически по окончании всех приоритетных потоков. По умолчанию создаваемый поток становится приоритетным. Но егоможно сделать фоновым, используя свойство IsBackground, определенное в классеThread, следующим образом.public bool IsBackground { get; set; }Для того чтобы сделать поток фоновым, достаточно присвоить логическое значениеtrue свойству IsBackground. А логическое значение false указывает на то, что потокявляется приоритетным.Приоритеты потоковУ каждого потока имеется свой приоритет, который отчасти определяет, насколькочасто поток получает доступ к ЦП. Вообще говоря, низкоприоритетные потоки получают доступ к ЦП реже, чем высокоприоритетные. Таким образом, в течение заданного промежутка времени низкоприоритетному потоку будет доступно меньше времениЦП, чем высокоприоритетному. Как и следовало ожидать, время ЦП, получаемое потоком, оказывает определяющее влияние на характер его выполнения и взаимодействия с другими потоками, исполняемыми в настоящий момент в системе.Следует иметь в виду, что, помимо приоритета, на частоту доступа потока к ЦПоказывают влияние и другие факторы. Так, если высокоприоритетный поток ожидает доступа к некоторому ресурсу, например для ввода с клавиатуры, он блокируется,а вместо него выполняется низкоприоритетный поток. В подобной ситуации низкоприоритетный поток может получать доступ к ЦП чаще, чем высокоприоритетныйпоток в течение определенного периода времени. И наконец, конкретное планирование задач на уровне операционной системы также оказывает влияние на время ЦП,выделяемое для потока.Когда порожденный поток начинает выполняться, он получает приоритет, устанавливаемый по умолчанию. Приоритет потока можно изменить с помощью свойстваPriority, являющегося членом класса Thread. Ниже приведена общая форма данного свойства:public ThreadPriority Priority{ get; set; }где ThreadPriority обозначает перечисление, в котором определяются приведенныениже значения приоритетов.ThreadPriority.HighestThreadPriority.AboveNormalThreadPriority.NormalThreadPriority.BelowNormalThreadPriority.LowestПо умолчанию для потока устанавливается значение приоритета ThreadPriority.Normal.Для того чтобы стало понятнее влияние приоритетов на исполнение потоков, обратимся к примеру, в котором выполняются два потока: один с более высоким приоритетом. Оба потока создаются в качестве экземпляров объектов класса MyThread.В методе Run() организуется цикл, в котором подсчитывается определенное числоповторений. Цикл завершается, когда подсчет достигает величины 1000000000 или когда статическая переменная stop получает логическое значение true. Первоначальнопеременная stop получает логическое значение false. В первом потоке, где производится подсчет до 1000000000, устанавливается логическое значение true переменной stop. В силу этого второй поток оканчивается на следующем своем интервалевремени. На каждом шаге цикла строка в переменной currentName проверяется наналичие имени исполняемого потока. Если имена потоков не совпадают, это означает, что произошло переключение исполняемых задач. Всякий раз, когда происходитпереключение задач, имя нового потока отображается и присваивается переменнойcurrentName. Это дает возможность отследить частоту доступа потока к ЦП. По окончании обоих потоков отображается число повторений цикла в каждом из них.// Продемонстрировать влияние приоритетов потоков.using System;using System.Threading;class MyThread {public int Count;public Thread Thrd;static bool stop = false;static string currentName;/ Сконструировать новый поток. Обратите внимание на то, чтоданный конструктор еще не начинает выполнение потоков. /public MyThread(string name) {Count = 0;Thrd = new Thread(this.Run);Thrd.Name = name;currentName = name;}// Начать выполнение нового потока.void Run() {Console.WriteLine("Поток " + Thrd.Name + " начат.");do {Count++;if(currentName != Thrd.Name) {currentName = Thrd.Name;Console.WriteLine("В потоке " + currentName);}} while(stop == false && Count < 1000000000);stop = true;Console.WriteLine("Поток " + Thrd.Name + " завершен.");}}class PriorityDemo {static void Main() {MyThread mt1 = new MyThread("с высоким приоритетом");MyThread mt2 = new MyThread("с низким приоритетом");// Установить приоритеты для потоков.mt1.Thrd.Priority = ThreadPriority.AboveNormal;mt2.Thrd.Priority = ThreadPriority.BelowNormal;// Начать потоки.mt1.Thrd.Start();mt2.Thrd.Start();mt1.Thrd.Join();mt2.Thrd.Join();Console.WriteLine();Console.WriteLine("Поток " + mt1.Thrd.Name +" досчитал до " + mt1.Count);Console.WriteLine("Поток " + mt2.Thrd.Name +" досчитал до " + mt2.Count);}}Вот к какому результату может привести выполнение этой программы.Поток с высоким приоритетом начат.В потоке с высоким приоритетомПоток с низким приоритетом начат.В потоке с низким приоритетомВ потоке с высоким приоритетомВ потоке с низким приоритетомВ потоке с высоким приоритетомВ потоке с низким приоритетомВ потоке с высоким приоритетомВ потоке с низким приоритетомВ потоке с высоким приоритетомВ потоке с низким приоритетомВ потоке с высоким приоритетомПоток с высоким приоритетом завершен.Поток с низким приоритетом завершен.Поток с высоким приоритетом досчитал до 1000000000Поток с низким приоритетом досчитал до 23996334Судя по результату, высокоприоритетный поток получил около 98% всего времени,которое было выделено для выполнения этой программы. Разумеется, конкретный результат может отличаться в зависимости от быстродействия ЦП и числа других задач,решаемых в системе, а также от используемой версии Windows.Многопоточный код может вести себя по-разному в различных средах, поэтомуникогда не следует полагаться на результаты его выполнения только в одной среде.Так, было бы ошибкой полагать, что низкоприоритетный поток из приведенного вышепримера будет всегда выполняться лишь в течение небольшого периода времени дотех пор, пока не завершится высокоприоритетный поток. В другой среде высокоприоритетный поток может, например, завершиться еще до того, как низкоприоритетныйпоток выполнится хотя бы один раз.СинхронизацияКогда используется несколько потоков, то иногда приходится координировать действия двух или более потоков. Процесс достижения такой координации называетсясинхронизацией. Самой распространенной причиной применения синхронизации служит необходимость разделять среди двух или более потоков общий ресурс, которыйможет быть одновременно доступен только одному потоку. Например, когда в одномпотоке выполняется запись информации в файл, второму потоку должно быть запрещено делать это в тот же самый момент времени. Синхронизация требуется и в томслучае, если один поток ожидает событие, вызываемое другим потоком. В подобнойситуации требуются какие-то средства, позволяющие приостановить один из потоковдо тех пор, пока не произойдет событие в другом потоке. После этого ожидающий поток может возобновить свое выполнение.В основу синхронизации положено понятие блокировки, посредством которой организуется управление доступом к кодовому блоку в объекте. Когда объект заблокирован одним потоком, остальные потоки не могут получить доступ к заблокированномукодовому блоку. Когда же блокировка снимается одним потоком, объект становитсядоступным для использования в другом потоке.Средство блокировки встроено в язык С#. Благодаря этому все объекты могут бытьсинхронизированы. Синхронизация организуется с помощью ключевого слова lock.Она была предусмотрена в C# с самого начала, и поэтому пользоваться ею намногопроще, чем кажется на первый взгляд. В действительности синхронизация объектов вомногих программах на С# происходит практически незаметно.Ниже приведена общая форма блокировки:lock(lockObj) {// синхронизируемые операторы}где lockObj обозначает ссылку на синхронизируемый объект. Если же требуется синхронизировать только один оператор, то фигурные скобки не нужны. Оператор lockгарантирует, что фрагмент кода, защищенный блокировкой для данного объекта, будет использоваться только в потоке, получающем эту блокировку. А все остальные потоки блокируются до тех пор, пока блокировка не будет снята. Блокировка снимаетсяпо завершении защищаемого ею фрагмента кода.Блокируемым считается такой объект, который представляет синхронизируемыйресурс. В некоторых случаях им оказывается экземпляр самого ресурса или же произвольный экземпляр объекта, используемого для синхронизации. Следует, однако,иметь в виду, что блокируемый объект не должен быть общедоступным, так как в противном случае он может быть заблокирован из другого, неконтролируемого в программе фрагмента кода и в дальнейшем вообще не разблокируется. В прошлом дляблокировки объектов очень часто применялась конструкция lock(this). Но она пригодна только в том случае, если this является ссылкой на закрытый объект. В связи свозможными программными и концептуальными ошибками, к которым может привести конструкция lock(this), применять ее больше не рекомендуется. Вместо неелучше создать закрытый объект, чтобы затем заблокировать его. Именно такой подходпринят в примерах программ, приведенных далее в этой главе. Но в унаследованномкоде C# могут быть обнаружены примеры применения конструкции lock(this).В одних случаях такой код оказывается безопасным, а в других — требует измененийво избежание серьезных осложнений при его выполнении.В приведенной ниже программе синхронизация демонстрируется на примереуправления доступом к методу SumIt(), суммирующему элементы целочисленногомассива.// Использовать блокировку для синхронизации доступа к объекту.using System;using System.Threading;class SumArray {int sum;object lockOn = new object(); // закрытый объект, доступный// для последующей блокировкиpublic int SumIt(int[] nums) {lock(lockOn) { // заблокировать весь методsum = 0; // установить исходное значение суммыfor(int i=0; i < nums.Length; i++) {sum += nums[i];Console.WriteLine("Текущая сумма для потока " +Thread.CurrentThread.Name + " равна " + sum);Thread.Sleep(10); // разрешить переключение задач}return sum;}}}class MyThread {public Thread Thrd;int[] a;int answer;// Создать один объект типа SumArray для всех// экземпляров класса MyThread.static SumArray sa = new SumArray();// Сконструировать новый поток,public MyThread(string name, int[] nums) {a = nums;Thrd = new Thread(this.Run);Thrd.Name = name;Thrd.Start(); // начать поток}// Начать выполнение нового потока.void Run() {Console.WriteLine(Thrd.Name + " начат.");answer = sa.SumIt(a);Console.WriteLine("Сумма для потока " + Thrd.Name + " равна " + answer);Console.WriteLine(Thrd.Name + " завершен.");}}class Sync {static void Main() {int[] a = {1, 2, 3, 4, 5);MyThread mt1 = new MyThread("Потомок #1", a);MyThread mt2 = new MyThread("Потомок #2", a);mt1.Thrd.Join();mt2.Thrd.Join();}}Ниже приведен результат выполнения данной программы, хотя у вас он может оказаться несколько иным.Потомок #1 начат.Текущая сумма для потока Потомок #1 равна 1Потомок #2 начат.Текущая сумма для потока Потомок #1 равна 3Текущая сумма для потока Потомок #1 равна 6Текущая сумма для потока Потомок #1 равна 10Текущая сумма для потока Потомок #1 равна 15Текущая сумма для потока Потомок #2 равна 1Сумма для потока Потомок #1 равна 15Потомок #1 завершен.Текущая сумма для потока Потомок #2 равна 3Текущая сумма для потока Потомок #2 равна 6Текущая сумма для потока Потомок #2 равна 10Текущая сумма для потока Потомок #2 равна 15Сумма для потока Потомок #2 равна 15Потомок #2 завершен.Как следует из приведенного выше результата, в обоих потоках правильно подсчитывается сумма, равная 15.Рассмотрим эту программу более подробно. Сначала в ней создаются три класса.Первым из них оказывается класс SumArray, в котором определяется метод SumIt(),суммирующий элементы целочисленного массива. Вторым создается класс MyThread,в котором используется статический объект sa типа SumArray. Следовательно, единственный объект типа SumArray используется всеми объектами типа MyThread. С помощью этого объекта получается сумма элементов целочисленного массива. Обратитевнимание на то, что текущая сумма запоминается в поле sum объекта типа SumArray.Поэтому если метод SumIt() используется параллельно в двух потоках, то оба потокапопытаются обратиться к полю sum, чтобы сохранить в нем текущую сумму. А поскольку это может привести к ошибкам, то доступ к методу SumIt() должен бытьсинхронизирован. И наконец, в третьем классе, Sync, создаются два потока, в которыхподсчитывается сумма элементов целочисленного массива.Оператор lock в методе SumIt() препятствует одновременному использованиюданного метода в разных потоках. Обратите внимание на то, что в операторе lock объект lockOn используется в качестве синхронизируемого. Это закрытый объект, предназначенный исключительно для синхронизации. Метод Sleep() намеренно вызываетсядля того, чтобы произошло переключение задач, хотя в данном случае это невозможно. Код в методе SumIt() заблокирован, и поэтому он может быть одновременно использован только в одном потоке. Таким образом, когда начинает выполняться второйпорожденный поток, он не сможет войти в метод SumIt() до тех пор, пока из него невыйдет первый порожденный поток. Благодаря этому гарантируется получение правильного результата.Для того чтобы полностью уяснить принцип действия блокировки, попробуйтеудалить из рассматриваемой здесь программы тело метода SumIt(). В итоге методSumIt() перестанет быть синхронизированным, а следовательно, он может параллельно использоваться в любом числе потоков для одного и того же объекта. Поскольку текущая сумма сохраняется в поле sum, она может быть изменена в каждом потоке,вызывающем метод SumIt(). Это означает, что если два потока одновременно вызывают метод SumIt() для одного и того же объекта, то конечный результат получаетсяневерным, поскольку содержимое поля sum отражает смешанный результат суммирования в обоих потоках. В качестве примера ниже приведен результат выполнениярассматриваемой здесь программы после снятия блокировки с метода SumIt().Потомок #1 начат.Текущая сумма для потока Потомок #1 равна 1Потомок #2 начат.Текущая сумма для потока Потомок #2 равна 1Текущая сумма для потока Потомок #1 равна 3Текущая сумма для потока Потомок #2 равна 5Текущая сумма для потока Потомок #1 равна 8Текущая сумма для потока Потомок #2 равна 11Текущая сумма для потока Потомок #1 равна 15Текущая сумма для потока Потомок #2 равна 19Текущая сумма для потока Потомок #1 равна 24Текущая сумма для потока Потомок #2 равна 29Сумма для потока Потомок #1 равна 29Потомок #1 завершен.Текущая сумма для потока Потомок #2 равна 29Потомок #2 завершен.Как следует из приведенного выше результата, в обоих порожденных потоках метод SumIt() используется одновременно для одного и того же объекта, а это приводитк искажению значения в поде sum.Ниже подведены краткие итоги использования блокировки.• Если блокировка любого заданного объекта получена в одном потоке, то послеблокировки объекта она не может быть получена в другом потоке.• Остальным потокам, пытающимся получить блокировку того же самого объекта, придется ждать до тех пор, пока объект не окажется в разблокированномсостоянии.• Когда поток выходит из заблокированного фрагмента кода, соответствующийобъект разблокируется.Другой подход к синхронизации потоковНесмотря на всю простоту и эффективность блокировки кода метода, как показанов приведенном выше примере, такое средство синхронизации оказывается пригоднымдалеко не всегда. Допустим, что требуется синхронизировать доступ к методу класса,который был создан кем-то другим и сам не синхронизирован. Подобная ситуациявполне возможна при использовании чужого класса, исходный код которого недоступен. В этом случае оператор lock нельзя ввести в соответствующий метод чужогокласса. Как же тогда синхронизировать объект такого класса? К счастью, этот вопросразрешается довольно просто: доступ к объекту может быть заблокирован из внешнего кода по отношению к данному объекту, для чего достаточно указать этот объект в операторе lock. В качестве примера ниже приведен другой вариант реализациипредыдущей программы. Обратите внимание на то, что код в методе SumIt() уже неявляется заблокированным, а объект lockOn больше не объявляется. Вместо этого вызовы метода SumIt() блокируются в классе MyThread.// Другой способ блокировки для синхронизации доступа к объекту.using System;using System.Threading;class SumArray {int sum;public int SumIt(int[] nums) {sum = 0; // установить исходное значение суммыfor (int i=0; i < nums.Length; i++) {sum += nums[i];Console.WriteLine("Текущая сумма для потока " +Thread.CurrentThread.Name + " равна " + sum);Thread.Sleep(10); // разрешить переключение задач}return sum;}}class MyThread {public Thread Thrd;int[] a;int answer;/ Создать один объект типа SumArray для всехэкземпляров класса MyThread. /static SumArray sa = new SumArray();// Сконструировать новый поток.public MyThread(string name, int[] nums) {a = nums;Thrd = new Thread(this.Run);Thrd.Name = name;Thrd.Start(); // начать поток}// Начать выполнение нового потока.void Run() {Console.WriteLine(Thrd.Name + " начат.");// Заблокировать вызовы метода SumIt().lock(sa) answer = sa.SumIt(a);Console.WriteLine("Сумма для потока " + Thrd.Name +" равна " + answer);Console.WriteLine(Thrd.Name + " завершен.");}}class Sync {static void Main() {int[] a = (1, 2, 3, 4, 5};MyThread mt1 = new MyThread("Потомок #1", a);MyThread mt2 = new MyThread("Потомок #2", a);mt1.Thrd.Join();mt2.Thrd.Join();}}В данной программе блокируется вызов метода sa.SumIt(), а не сам методSumIt(). Ниже приведена соответствующая строка кода, в которой осуществляетсяподобная блокировка.// Заблокировать вызовы метода SumIt().lock(sa) answer = sa.SumIt(а);Объект sa является закрытым, и поэтому он может быть благополучно заблокирован. При таком подходе к синхронизации потоков данная программа дает такой жеправильный результат, как и при первоначальном подходе.Класс Monitor и блокировкаКлючевое слово lock на самом деде служит в C# быстрым способом доступа ксредствам синхронизации, определенным в классе Monitor, который находится в пространстве имен System.Threading. В этом классе определен, в частности, ряд методовдля управления синхронизацией. Например, для получения блокировки объекта вызывается метод Enter(), а для снятия блокировки — метод Exit(). Ниже приведеныобщие формы этих методов:public static void Enter(object obj)public static void Exit(object obj)где obj обозначает синхронизируемый объект. Если же объект недоступен, то послевызова метода Enter() вызывающий поток ожидает до тех пор, пока объект не станетдоступным. Тем не менее методы Enter() и Exit() применяются редко, посколькуоператор lock автоматически предоставляет эквивалентные средства синхронизациипотоков. Именно поэтому оператор lock оказывается "более предпочтительным" дляполучения блокировки объекта при программировании на С#.Впрочем, один метод из класса Monitor может все же оказаться полезным. Этометод TryEnter(), одна из общих форм которого приведена ниже.public static bool TryEnter(object obj)Этот метод возвращает логическое значение true, если вызывающий поток получает блокировку для объекта obj, а иначе он возвращает логическое значение false.Но в любом случае вызывающему потоку придется ждать своей очереди. С помощьюметода TryEnter() можно реализовать альтернативный вариант синхронизации потоков, если требуемый объект временно недоступен.Кроме того, в классе Monitor определены методы Wait(), Pulse() и PulseAll(),которые рассматриваются в следующем разделе.Сообщение между потоками с помощью методовWait(), Pulse() и PulseAll()Рассмотрим следующую ситуацию. Поток Т выполняется в кодовом блоке lock,и ему требуется доступ к ресурсу R, который временно недоступен. Что же тогда делатьпотоку Т? Если поток Т войдет в организованный в той или иной форме цикл опроса,ожидая освобождения ресурса R, то тем самым он свяжет соответствующий объект,блокируя доступ к нему других потоков. Это далеко не самое оптимальное решение,поскольку оно лишает отчасти преимуществ программирования для многопоточнойсреды. Более совершенное решение заключается в том, чтобы временно освободитьобъект и тем самым дать возможность выполняться другим потокам. Такой подходосновывается на некоторой форме сообщения между потоками, благодаря которомуодин поток может уведомлять другой о том, что он заблокирован и что другой потокможет возобновить свое выполнение. Сообщение между потоками организуется в C# спомощью методов Wait(), Pulse() и PulseAll().Методы Wait(), Pulse() и PulseAll() определены в классе Monitor и могутвызываться только из заблокированного фрагмента блока. Они применяются следующим образом. Когда выполнение потока временно заблокировано, он вызывает методWait(). В итоге поток переходит в состояние ожидания, а блокировка с соответствующего объекта снимается, что дает возможность использовать этот объект в другом потоке. В дальнейшем ожидающий поток активизируется, когда другой поток войдет ваналогичное состояние блокировки, и вызывает метод Pulse() или PulseAll(). Привызове метода Pulse() возобновляется выполнение первого потока, ожидающего своей очереди на получение блокировки. А вызов метода PulseAll() сигнализирует оснятии блокировки всем ожидающим потокам.Ниже приведены две наиболее часто используемые формы метода Wait().public static bool Wait(object obj)public static bool Wait(object obj, int миллисекундпростоя)В первой форме ожидание длится вплоть до уведомления об освобождении объекта, а во второй форме — как до уведомления об освобождении объекта, так и до истечения периода времени, на который указывает количество миллисекундпростоя.В обеих формах obj обозначает объект, освобождение которого ожидается.Ниже приведены общие формы методов Pulse() и PulseAll():public static void Pulse(object obj)public static void PulseAll(object obj)где obj обозначает освобождаемый объект.Если методы Wait(), Pulse() и PulseAll() вызываются из кода, находящегосяза пределами синхронизированного кода, например из блока lock, то генерируетсяисключение SynchronizationLockException.Пример использования методов Wait() и Pulse()Для того чтобы стало понятнее назначение методов Wait() и Pulse(), рассмотримпример программы, имитирующей тиканье часов и отображающей этот процесс наэкране словами "тик" и "так". Для этой цели в программе создается класс TickTock,содержащий два следующих метода: Tick() и Тоск(). Метод Tick() выводит наэкран слово "тик", а метод Тоск() — слово "так". Для запуска часов далее в программесоздаются два потока: один из них вызывает метод Tick(), а другой — метод Тоск().Преследуемая в данном случае цель состоит в том, чтобы оба потока выполнялись, поочередно выводя на экран слова "тик" и "так", из которых образуется повторяющийсяряд "тик-так", имитирующий ход часов.// Использовать методы Wait() и Pulse() для имитации тиканья часов.using System;using System.Threading;class TickTock {object lockOn = new object();public void Tick(bool running) {lock(lockOn) {if(!running) { // остановить часыMonitor.Pulse(lockOn); // уведомить любые ожидающие потокиreturn;}Console.Write("тик ");Monitor.Pulse(lockOn); // разрешить выполнение метода Tock()Monitor.Wait(lockOn); // ожидать завершения метода Tock()}}public void Tock(bool running) {lock(lockOn) {if(!running) { // остановить часыMonitor.Pulse(lockOn); // уведомить любые ожидающие потокиreturn;}Console.WriteLine("так");Monitor.Pulse(lockOn); // разрешить выполнение метода Tick()Monitor.Wait(lockOn); // ожидать завершения метода Tick()}}}class MyThread {public Thread Thrd;TickTock ttOb;// Сконструировать новый поток.public MyThread(string name, TickTock tt) {Thrd = new Thread(this.Run);ttOb = tt;Thrd.Name = name;Thrd.Start();}// Начать выполнение нового потока.void Run() {if(Thrd.Name == "Tick") {for(int i=0; i<5; i++) ttOb.Tick(true);ttOb.Tick(false);}else {for(int i=0; i<5; i++) ttOb.Tock(true);ttOb.Tock(false);}}}class TickingClock {static void Main() {TickTock tt = new TickTock();MyThread mt1 = new MyThread("Tick", tt);MyThread mt2 = new MyThread("Tock", tt);mt1.Thrd.Join();mt2.Thrd.Join();Console.WriteLine("Часы остановлены");}}Ниже приведен результат выполнения этой программы.тик тактик тактик тактик тактик такЧасы остановленыРассмотрим эту программу более подробно. В методе Main() создается объект ttтипа TickTock, который используется для запуска двух потоков на выполнение. Еслив методе Run() из класса MyThread обнаруживается имя потока Tick, соответствующее ходу часов "тик", то вызывается метод Tick(). А если это имя потока Тоск, соответствующее ходу часов "так", то вызывается метод Тоск(). Каждый из этих методоввызывается пять раз подряд с передачей логического значения true в качестве apiy-мента. Часы идут до тех пор, пока этим методам передается логическое значение true,и останавливаются, как только передается логическое значение false.Самая важная часть рассматриваемой здесь программы находится в методахTick() и Тоск(). Начнем с метода Tick(), код которого для удобства приводитсяниже.public void Tick(bool running) {lock(lockOn) {if((running) { // остановить часыMonitor.Pulse(lockOn); // уведомить любые ожидающие потокиreturn;}Console.Write("тик ");Monitor.Pulse(lockOn); // разрешить выполнение метода Tock()Monitor.Wait(lockOn); // ожидать завершения метода Tock()}}Прежде всего обратите внимание на код метода Tick() в блоке lock. Напомним,что методы Wait() и Pulse() могут использоваться только в синхронизированныхблоках кода. В начале метода Tick() проверяется значение текущего параметра, которое служит явным признаком остановки часов. Если это логическое значение false,то часы остановлены. В этом случае вызывается метод Pulse(), разрешающий выполнение любого потока, ожидающего своей очереди. Мы еще вернемся к этому моментув дальнейшем. Если же часы идут при выполнении метода Tick(), то на экран выводится слово "тик" с пробелом, затем вызывается метод Pulse(), а после него — методWait(). При вызове метода Pulse() разрешается выполнение потока для того жесамого объекта, а при вызове метода Wait() выполнение метода Tick() приостанавливается до тех пор, пока метод Pulse() не будет вызван из другого потока. Такимобразом, когда вызывается метод Tick(), отображается одно слово "тик" с пробелом,разрешается выполнение другого потока, а затем выполнение данного метода приостанавливается.Метод Tock() является точной копией метода Tick(), за исключением того, чтоон выводит на экран слово "так". Таким образом, при входе в метод Tock() на экранвыводится слово "так", вызывается метод Pulse(), а затем выполнение метода Tock()приостанавливается. Методы Tick() и Tock() можно рассматривать как поочередносменяющие друг друга, т.е. они взаимно синхронизированы.Когда часы остановлены, метод Pulse() вызывается для того, чтобы обеспечитьуспешный вызов метода Wait(). Напомним, что метод Wait() вызывается в обоихметодах, Tick() и Tock(), после вывода соответствующего слова на экран. Но дело втом, что когда часы остановлены, один из этих методов все еще находится в состоянииожидания. Поэтому завершающий вызов метода Pulse() требуется, чтобы выполнить ожидающий метод до конца. В качестве эксперимента попробуйте удалить этотвызов метода Pulse() и понаблюдайте за тем, что при этом произойдет. Вы сразу жеобнаружите, что программа "зависает", и для выхода из нее придется нажать комбинацию клавиш . Дело в том, что когда метод Wait() вызывается в последнемвызове метода Tock(), соответствующий ему метод Pulse() не вызывается, а значит,выполнение метода Tock() оказывается незавершенным, и он ожидает своей очередидо бесконечности.Прежде чем переходить к чтению следующего раздела, убедитесь сами, если, конечно, сомневаетесь, в том, что следует обязательно вызывать методы Wait() и Pulse(),чтобы имитируемые часы шли правильно. Для этого подставьте приведенный нижевариант класса TickTock в рассматриваемую здесь программу. В этом варианте всевызовы методов Wait() и Pulse() исключены.// Нерабочий вариант класса TickTock.class TickTock {object lockOn = new object();public void Tick(bool running) {lock(lockOn) {if(!running) { // остановить часыreturn;}Console.Write("тик ");}}public void Tock(bool running) {lock(lockOn) {if(!running) { // остановить часыreturn;}Console.WriteLine("так");}}}После этой подстановки результат выполнения данной программы будет выглядетьследующим образом.тик тик тик тик тик тактактактактакЧасы остановленыОчевидно, что методы Tick() и Тосk() больше не синхронизированы!Взаимоблокировка и состояние гонкиПри разработке многопоточных программ следует быть особенно внимательным,чтобы избежать взаимоблокировки и состояний гонок. Взаимоблокировка, как подразумевает само название, — это ситуация, в которой один поток ожидает определенныхдействий от другого потока, а другой поток, в свою очередь, ожидает чего-то от первого потока. В итоге оба потока приостанавливаются, ожидая друг друга, и ни один изних не выполняется. Эта ситуация напоминает двух слишком вежливых людей, каждый из которых настаивает на том, чтобы другой прошел в дверь первым!На первый взгляд избежать взаимоблокировки нетрудно, но на самом деле не все такпросто, ведь взаимоблокировка может возникать окольными путями. В качестве примера рассмотрим класс TickTock из предыдущей программы. Как пояснялось выше,в отсутствие завершающего вызова метода Pulse() из метода Tick() или Тосk() тотили другой будет ожидать до бесконечности, что приведет к "зависанию" программывследствие взаимоблокировки. Зачастую причину взаимоблокировки не так-то простовыяснить, анализируя исходный код программы, поскольку параллельно действующиепроцессы могут взаимодействовать довольно сложным образом во время выполнения.Для исключения взаимоблокировки требуется внимательное программирование итщательное тестирование. В целом, если многопоточная программа периодически "зависает", то наиболее вероятной причиной этого является взаимоблокировка.Состояние гонки возникает в том случае, когда два потока или больше пытаютсяодновременно получить доступ к общему ресурсу без должной синхронизации. Так,в одном потоке может сохраняться значение в переменной, а в другом — инкрементироваться текущее значение этой же переменной. В отсутствие синхронизации конечный результат будет зависеть от того, в каком именно порядке выполняются потоки:инкрементируется ли значение переменной во втором потоке или же оно сохраняетсяв первом. О подобной ситуации говорят, что потоки "гоняются друг за другом", причем конечный результат зависит от того, какой из потоков завершится первым. Возникающее состояние гонок, как и взаимоблокировку, непросто обнаружить. Поэтому еголучше предотвратить, синхронизируя должным образом доступ к общим ресурсампри программировании.Применение атрибута MethodImplAttributeМетод может быть полностью синхронизирован с помощью атрибутаMethodImplAttribute. Такой подход может стать альтернативой оператору lock в тех случаях, когда метод требуется заблокировать полностью. АтрибутMethodImplAttribute определен в пространстве имен Sуstem.Runtime.CompilerServices. Ниже приведен конструктор, применяемый для подобнойсинхронизации:public MethodImplAttribute(MethodImplOptions methodImplOptions)где methodImplOptions обозначает атрибут реализации. Для синхронизации методадостаточно указать атрибут MethodImplOptions.Synchronized. Этот атрибут вызывает блокировку всего метода для текущего экземпляра объекта, доступного по ссылкеthis. Если же метод относится к типу static, то блокируется его тип. Поэтому данный атрибут непригоден для применения в открытых объектах иди классах.Ниже приведена еще одна версия программы, имитирующей тиканье часов, с переделанным вариантом класса TickTock, в котором атрибут MethodImplOptions обеспечивает должную синхронизацию.// Использовать атрибут MethodImplAttribute для синхронизации метода.using System;using System.Threading;using System.Runtime.CompilerServices;// Вариант класса TickTock, переделанный с целью// использовать атрибут MethodlmplOptions.Synchronized.class TickTock {/ Следующий атрибут полностью синхронизирует метод Tick(). /[MethodImplAttribute(MethodImplOptions.Synchronized)]public void Tick(bool running) {if(!running) { // остановить часыMonitor.Pulse(this); // уведомить любые ожидающие потокиreturn;}Console.Write("тик ");Monitor.Pulse(this); // разрешить выполнение метода Tock()Monitor.Wait(this); // ожидать завершения метода Tock()}/ Следующий атрибут полностью синхронизирует метод Tock(). /[MethodImplAttribute(MethodImplOptions.Synchronized)]public void Tock(bool running) {if(!running) { // остановить часыMonitor.Pulse(this); // уведомить любые ожидающие потокиreturn;}Console.WriteLine("так");Monitor.Pulse(this); // разрешить выполнение метода Tick()Monitor.Wait(this); // ожидать завершения метода Tick()}}class MyThread {public Thread Thrd;TickTock ttOb;// Сконструировать новый поток.public MyThread(string name, TickTock tt) {Thrd = new Thread(this.Run);ttOb = tt;Thrd.Name = name;Thrd.Start();}// Начать выполнение нового потока.void Run() {if(Thrd.Name == "Tick") {for(int i=0; i<5; i++) ttOb.Tick(true);ttOb.Tick(false);}else {for(int i=0; i<5; i++) ttOb.Tock(true);ttOb.Tock(false);}}}class TickingClock {static void Main() {TickTock tt = new TickTock();MyThread mt1 = new MyThread("Tick", tt);MyThread mt2 = new MyThread("Tock", tt);mt1.Thrd.Join();mt2.Thrd.Join();Console.WriteLine("Часы остановлены");}}Эта версия программы дает такой же результат, как и предыдущая.Синхронизируемый метод не определен в открытом классе и не вызывается для открытого объекта, поэтому применение оператора lock или атрибутаMethodImplAttribute зависит от личных предпочтений. Ведь и тот и другой дает одини тот же результат. Но поскольку ключевое слово lock относится непосредственно кязыку С#, то в примерах, приведенных в этой книге, предпочтение отдано именно ему.ПРИМЕЧАНИЕНе применяйте атрибут MethodImplAttribute в открытых классах или экземплярахоткрытых объектов. Вместо этого пользуйтесь оператором lock, чтобы заблокировать методдля закрытого объекта, как пояснялось ранее.Применение мьютекса и семафораВ большинстве случаев, когда требуется синхронизация, оказывается достаточнои оператора lock. Тем не менее в некоторых случаях, как, например, при ограничениидоступа к общим ресурсам, более удобными оказываются механизмы синхронизации,встроенные в среду .NET Framework. Ниже рассматриваются по порядку два таких механизма: мьютекс и семафор.МьютексМьютекс представляет собой взаимно исключающий синхронизирующий объект. Это означает, что он может быть получен потоком только по очереди. Мьютекспредназначен для тех ситуаций, в которых общий ресурс может быть одновременноиспользован только в одном потоке. Допустим, что системный журнал совместно используется в нескольких процессах, но только в одном из них данные могут записываться в файл этого журнала в любой момент времени. Для синхронизации процессовв данной ситуации идеально подходит мьютекс.Мьютекс поддерживается в классе System.Threading.Mutex. У него имеется несколько конструкторов. Ниже приведены два наиболее употребительных конструктора.public Mutex()public Mutex(bool initiallyOwned)В первой форме конструктора создается мьютекс, которым первоначально никто невладеет. А во второй форме исходным состоянием мьютекса завладевает вызывающийпоток, если параметр initiallyOwned имеет логическое значение true. В противномслучае мьютексом никто не владеет.Для того чтобы получить мьютекс, в коде программы следует вызвать методWaitOne() для этого мьютекса. Метод WaitOne() наследуется классом Mutex от класса Thread.WaitHandle. Ниже приведена его простейшая форма.public bool WaitOne();Метод WaitOne() ожидает до тех пор, пока не будет получен мьютекс, для которого он был вызван. Следовательно, этот метод блокирует выполнение вызывающего потока до тех пор, пока не станет доступным указанный мьютекс. Он всегда возвращаетлогическое значение true.Когда же в коде больше не требуется владеть мьютексом, он освобождается посредством вызова метода ReleaseMutex(), форма которого приведена ниже.public void ReleaseMutex()В этой форме метод ReleaseMutex() освобождает мьютекс, для которого он былвызван, что дает возможность другому потоку получить данный мьютекс.Для применения мьютекса с целью синхронизировать доступ к общему ресурсуупомянутые выше методы WaitOne() и ReleaseMutex() используются так, как показано в приведенном ниже фрагменте кода.Mutex myMtx = new Mutex();// ...myMtx.WaitOne(); // ожидать получения мьютекса// Получить доступ к общему ресурсу.myMtx.ReleaseMutex(); // освободить мьютексПри вызове метода WaitOne() выполнение соответствующего потока приостанавливается до тех пор, пока не будет получен мьютекс. А при вызове методаReleaseMutex() мьютекс освобождается и затем может быть получен другим потоком. Благодаря такому подходу к синхронизации одновременный доступ к общемуресурсу ограничивается только одним потоком.В приведенном ниже примере программы описанный выше механизм синхронизации демонстрируется на практике. В этой программе создаются два потока в видеклассов IncThread и DecThread, которым требуется доступ к общему ресурсу: переменной SharedRes.Count. В потоке IncThread переменная SharedRes.Countинкрементируется, а в потоке DecThread — декрементируется. Во избежание одновременного доступа обоих потоков к общему ресурсу SharedRes.Count этот доступсинхронизируется мьютексом Mtx, также являющимся членом класса SharedRes.// Применить мьютекс.using System;using System.Threading;// В этом классе содержится общий ресурс(переменная Count),// а также мьютекс (Mtx), управляющий доступом к ней.class SharedRes {public static int Count = 0;public static Mutex Mtx = new Mutex();}// В этом потоке переменная SharedRes.Count инкрементируется.class IncThread {int num;public Thread Thrd;public IncThread(string name, int n) {Thrd = new Thread(this.Run);num = n;Thrd.Name = name;Thrd.Start();}// Точка входа в поток.void Run() {Console.WriteLine(Thrd.Name + " ожидает мьютекс.");// Получить мьютекс.SharedRes.Mtx.WaitOne();Console.WriteLine(Thrd.Name + " получает мьютекс.");do {Thread.Sleep(500);SharedRes.Count++;Console.WriteLine("В потоке " + Thrd.Name +", SharedRes.Count = " + SharedRes.Count);num--;} while(num > 0);Console.WriteLine(Thrd.Name + " освобождает мьютекс.");// Освободить мьютекс.SharedRes.Mtx.ReleaseMutex();}}//В этом потоке переменная SharedRes.Count декрементируется.class DecThread {int num;public Thread Thrd;public DecThread(string name, int n) {Thrd = new Thread(new ThreadStart(this.Run));num = n;Thrd.Name = name;Thrd.Start();}// Точка входа в поток.void Run() {Console.WriteLine(Thrd.Name + " ожидает мьютекс.");// Получить мьютекс.SharedRes.Mtx.WaitOne();Console.WriteLine(Thrd.Name + " получает мьютекс.");do {Thread.Sleep(500);SharedRes.Count--;Console.WriteLine("В потоке " + Thrd.Name +", SharedRes.Count = " + SharedRes.Count);num--;} while(num > 0);Console.WriteLine(Thrd.Name + " освобождает мьютекс.");// Освободить мьютекс.SharedRes.Mtx.ReleaseMutex();}}class MutexDemo {static void Main() {// Сконструировать два потока.IncThread mt1 = new IncThread("Инкрементирующий Поток", 5);Thread.Sleep(1); // разрешить инкрементирующему потоку начатьсяDecThread mt2 = new DecThread("Декрементирующий Поток", 5);mt1.Thrd.Join();mt2.Thrd.Join();}}Эта программа дает следующий результат.Инкрементирующий Поток ожидает мьютекс.Инкрементирующий Поток получает мьютекс.Декрементирующий Поток ожидает мьютекс.В потоке Инкрементирующий Поток, SharedRes.Count = 1В потоке Инкрементирующий Поток, SharedRes.Count = 2В потоке Инкрементирующий Поток, SharedRes.Count = 3В потоке Инкрементирующий Поток, SharedRes.Count = 4В потоке Инкрементирующий Поток, SharedRes.Count = 5Инкрементирующий Поток освобождает мьютекс.Декрементирующий Поток получает мьютекс.В потоке Декрементирующий Поток, SharedRes.Count = 4В потоке Декрементирующий Поток, SharedRes.Count = 3В потоке Декрементирующий Поток, SharedRes.Count = 2В потоке Декрементирующий Поток, SharedRes.Count = 1В потоке Декрементирующий Поток, SharedRes.Count = 0Декрементирующий Поток освобождает мьютекс.Как следует из приведенного выше результата, доступ к общему ресурсу (переменной SharedRes.Count) синхронизирован, и поэтому значение данной переменнойможет быть одновременно изменено только в одном потоке.Для того чтобы убедиться в том, что мьютекс необходим для получения приведенного выше результата, попробуйте закомментировать вызовы методов WaitOne()и ReleaseMutex() в исходном коде рассматриваемой здесь программы. При ее последующем выполнении вы получите следующий результат, хотя у вас он может оказаться несколько иным.В потоке Инкрементирующий Поток, SharedRes.Count = 1В потоке Декрементирующий Поток, SharedRes.Count = 0В потоке Инкрементирующий Поток, SharedRes.Count = 1В потоке Декрементирующий Поток, SharedRes.Count = 0В потоке Инкрементирующий Поток, SharedRes.Count = 1В потоке Декрементирующий Поток, SharedRes.Count = 0В потоке Инкрементирующий Поток, SharedRes.Count = 1В потоке Декрементирующий Поток, SharedRes.Count = 0В потоке Инкрементирующий Поток, SharedRes.Count = 1Как следует из приведенного выше результата, без мьютекса инкрементирование идекрементирование переменной SharedRes.Count происходит, скорее, беспорядочно, чем последовательно.Мьютекс, созданный в предыдущем примере, известен только тому процессу, который его породил. Но мьютекс можно создать и таким образом, чтобы он был известенгде-нибудь еще. Для этого он должен быть именованным. Ниже приведены формыконструктора, предназначенные для создания такого мьютекса.public Mutex(bool initiallyOwned, string имя)public Mutex(bool initiallyOwned, string имя, out bool createdNew)В обеих формах конструктора имя обозначает конкретное имя мьютекса. Если впервой форме конструктора параметр initiallyOwned имеет логическое значениеtrue, то владение мьютексом запрашивается. Но поскольку мьютекс может принадлежать другому процессу на системном уровне, то для этого параметра лучше указатьлогическое значение false. А после возврата из второй формы конструктора параметр createdNew будет иметь логическое значение true, если владение мьютексомбыло запрошено и получено, и логическое значение false, если запрос на владениебыл отклонен. Существует и третья форма конструктора типа Mutex, в которой допускается указывать управляющий доступом объект типа MutexSecurity. С помощьюименованных мьютексов можно синхронизировать взаимодействие процессов.И последнее замечание: в потоке, получившем мьютекс, допускается делать одиниди несколько дополнительных вызовов метода WaitOne() перед вызовом методаReleaseMutex(), причем все эти дополнительные вызовы будут произведены успешно. Это означает, что дополнительные вызовы метода WaitOne() не будут блокироватьпоток, который уже владеет мьютексом. Но количество вызовов метода WaitOne()должно быть равно количеству вызовов метода ReleaseMutex() перед освобождением мьютекса.СемафорСемафор подобен мьютексу, за исключением того, что он предоставляет одновременный доступ к общему ресурсу не одному, а нескольким потокам. Поэтому семафорпригоден для синхронизации целого ряда ресурсов. Семафор управляет доступом кобщему ресурсу, используя для этой цели счетчик. Если значение счетчика большенуля, то доступ к ресурсу разрешен. А если это значение равно нулю, то доступ к ресурсу запрещен. С помощью счетчика ведется подсчет количества разрешений. Следовательно, для доступа к ресурсу поток должен получить разрешение от семафора.Обычно поток, которому требуется доступ к общему ресурсу, пытается получитьразрешение от семафора. Если значение счетчика семафора больше нуля, то потокполучает разрешение, а счетчик семафора декрементируется. В противном случае поток блокируется до тех пор, пока не получит разрешение. Когда же потоку больше нетребуется доступ к общему ресурсу, он высвобождает разрешение, а счетчик семафораинкрементируется. Если разрешения ожидает другой поток, то он получает его в этотмомент. Количество одновременно разрешаемых доступов указывается при созданиисемафора. Так, если создать семафор, одновременно разрешающий только один доступ, то такой семафор будет действовать как мьютекс.Семафоры особенно полезны в тех случаях, когда общий ресурс состоит из группыиди пуда ресурсов. Например, пул ресурсов может состоять из целого ряда сетевыхсоединений, каждое из которых служит для передачи данных. Поэтому потоку, которому требуется сетевое соединение, все равно, какое именно соединение он получит.В данном случае семафор обеспечивает удобный механизм управления доступом к сетевым соединениям.Семафор реализуется в классе System.Threading.Semaphore, у которого имеетсянесколько конструкторов. Ниже приведена простейшая форма конструктора данногокласса:public Semaphore(int initialCount, int maximumCount)где initialCount — это первоначальное значение для счетчика разрешений семафора, т.е. количество первоначально доступных разрешений; maximumCount — максимальное значение данного счетчика, т.е. максимальное количество разрешений, которые может дать семафор.Семафор применяется таким же образом, как и описанный ранее мьютекс. В целях получения доступа к ресурсу в коде программы вызывается метод WaitOne() длясемафора. Этот метод наследуется классом Semaphore от класса WaitHandle. МетодWaitOne() ожидает до тех пор, пока не будет получен семафор, для которого он вызывается. Таким образом, он блокирует выполнение вызывающего потока до тех пор,пока указанный семафор не предоставит разрешение на доступ к ресурсу.Если коду больше не требуется владеть семафором, он освобождает его, вызываяметод Release(). Ниже приведены две формы этого метода.public int Release()public int Release(int releaseCount)В первой форме метод Release() высвобождает только одно разрешение, а вовторой форме — количество разрешений, определяемых параметром releaseCount.В обеих формах данный метод возвращает подсчитанное количество разрешений, существовавших до высвобождения.Метод WaitOne() допускается вызывать в потоке несколько раз перед вызовом метода Release(). Но количество вызовов метода WaitOne() должно быть равно количеству вызовов метода Release() перед высвобождением разрешения. С другойстороны, можно воспользоваться формой вызова метода Release(int num), чтобыпередать количество высвобождаемых разрешений, равное количеству вызовов методаWaitOne().Ниже приведен пример программы, в которой демонстрируется применение семафора. В этой программе семафор используется в классе MyThread для одновременного выполнения только двух потоков типа MyThread. Следовательно, разделяемымресурсом в данном случае является ЦП.// Использовать семафор.using System;using System.Threading;// Этот поток разрешает одновременное выполнение// только двух своих экземпляров.class MyThread {public Thread Thrd;// Здесь создается семафор, дающий только два// разрешения из двух первоначально имеющихся.static Semaphore sem = new Semaphore(2, 2);public MyThread(string name) {Thrd = new Thread(this.Run);Thrd.Name = name;Thrd.Start();}// Точка входа в поток.void Run() {Console.WriteLine(Thrd.Name + " ожидает разрешения.");sem.WaitOne();Console.WriteLine(Thrd.Name + " получает разрешение.");for(char ch='A'; ch < 'D'; ch++) {Console.WriteLine(Thrd.Name + " : " + ch + " ");Thread.Sleep(500);}Console.WriteLine(Thrd.Name + " высвобождает разрешение.");// Освободить семафор.sem.Release();}}class SemaphoreDemo {static void Main() {// Сконструировать три потока.MyThread mt1 = new MyThread("Поток #1");MyThread mt2 = new MyThread("Поток #2");MyThread mt3 = new MyThread("Поток #3");mt1.Thrd.Join();mt2.Thrd.Join();mt3.Thrd.Join();}}В классе MyThread объявляется семафор sem, как показано ниже.static Semaphore sem = new Semaphore(2, 2);При этом создается семафор, способный дать не более двух разрешений на доступк ресурсу из двух первоначально имеющихся разрешений.Обратите внимание на то, что выполнение метода MyThread.Run() не может бытьпродолжено до тех пор, пока семафор sem не даст соответствующее разрешение. Еслиразрешение отсутствует, то выполнение потока приостанавливается. Когда же разрешение появляется, выполнение потока возобновляется. В методе In Main() создаютсятри потока. Но выполняться могут только два первых потока, а третий должен ожидать окончания одного из этих двух потоков. Ниже приведен результат выполнениярассматриваемой здесь программы, хотя у вас он может оказаться несколько иным.Поток #1 ожидает разрешения.Поток #1 получает разрешение.Поток #1 : АПоток #2 ожидает разрешения.Поток #2 получает разрешение.Поток #2 : АПоток #3 ожидает разрешения.Поток #1 : ВПоток #2 : ВПоток #1 : СПоток #2 : СПоток #1 высвобождает разрешение.Поток #3 получает разрешение.Поток #3 : АПоток #2 высвобождает разрешение.Поток #3 : ВПоток #3 : СПоток #3 высвобождает разрешение.Семафор, созданный в предыдущем примере, известен только тому процессу, который его породил. Но семафор можно создать и таким образом, чтобы он был известенгде-нибудь еще. Для этого он должен быть именованным. Ниже приведены формыконструктора класса Semaphore, предназначенные для создания такого семафора.public Semaphore(int initialCount, int maximumCount, string имя)public Semaphore(int initialCount, int maximumCount, string имя,out bool createdNew)В обеих формах имя обозначает конкретное имя, передаваемое конструктору. Еслив первой форме семафор, на который указывает имя, еще не существует, то он создается с помощью значений, определяемых параметрами initialCount и maximumCount.А если он уже существует, то значения параметров initialCount и maximumCountигнорируются. После возврата из второй формы конструктора параметр createdNewбудет иметь логическое значение true, если семафор был создан. В этом случае значения параметров initialCount и maximumCount используются для создания семафора.Если же параметр createdNew будет иметь логическое значение false, значит, семафор уже существует и значения параметров initialCount и maximumCount игнорируются. Существует и третья форма конструктора класса Semaphore, в которой допускается указывать управляющий доступом объект типа SemaphoreSecurity. С помощьюименованных семафоров можно синхронизировать взаимодействие процессов.Применение событийДля синхронизации в C# предусмотрен еще один тип объекта: событие. Существуют две разновидности событий: устанавливаемые в исходное состояние вручную и автоматически. Они поддерживаются в классах ManualResetEvent и AutoResetEventсоответственно. Эти классы являются производными от класса EventWaitHandle, находящегося на верхнем уровне иерархии классов, и применяются в тех случаях, когдаодин поток ожидает появления некоторого события в другом потоке. Как только такоесобытие появляется, второй поток уведомляет о нем первый поток, позволяя тем самым возобновить его выполнение.Ниже приведены конструкторы классов ManualResetEvent и AutoResetEvent.public ManualResetEvent(bool initialState)public AutoResetEvent(bool initialState)Если в обеих формах параметр initialState имеет логическое значение true, тоо событии первоначально уведомляется. А если он имеет логическое значение false,то о событии первоначально не уведомляется.Применяются события очень просто. Так, для события типа ManualResetEventпорядок применения следующий. Поток, ожидающий некоторое событие, вызываетметод WaitOne() для событийного объекта, представляющего данное событие. Еслисобытийный объект находится в сигнальном состоянии, то происходит немедленныйвозврат из метода WaitOne(). В противном случае выполнение вызывающего потокаприостанавливается до тех пор, пока не будет получено уведомление о событии. Кактолько событие произойдет в другом потоке, этот поток установит событийный объектв сигнальное состояние, вызвав метод Set(). Поэтому метод Set() следует рассматривать как уведомляющий о том, что событие произошло. После установки событийного объекта в сигнальное состояние произойдет немедленный возврат из методаWaitOne(), и первый поток возобновит свое выполнение. А в результате вызова метода Reset() событийный объект возвращается в несигнальное состояние.Событие типа AutoResetEvent отличается от события типа ManualResetEventлишь способом установки в исходное состояние. Если для события типаManualResetEvent событийный объект остается в сигнальном состоянии до тех пор,пока не будет вызван метод Reset(), то для события типа AutoResetEvent событийный объект автоматически переходит в несигнальное состояние, как только поток,ожидающий это событие, получит уведомление о нем и возобновит свое выполнение. Поэтому если применяется событие типа AutoResetEvent, то вызывать методReset() необязательно.В приведенном ниже примере программы демонстрируется применение событиятипа ManualResetEvent.// Использовать событийный объект, устанавливаемый// в исходное состояние вручную.using System;using System.Threading;// Этот поток уведомляет о том, что событие передано его конструктору.class MyThread {public Thread Thrd;ManualResetEvent mre;public MyThread(string name, ManualResetEvent evt) {Thrd = new Thread(this.Run);Thrd.Name = name;mre = evt;Thrd.Start();}// Точка входа в поток.void Run() {Console.WriteLine("Внутри потока " + Thrd.Name);for(int i=0; i<5; i++) {Console.WriteLine(Thrd.Name);Thread.Sleep(500);}Console.WriteLine(Thrd.Name + " завершен!");// Уведомить о событии.mre.Set();}}class ManualEventDemo {static void Main() {ManualResetEvent evtObj = new ManualResetEvent(false);MyThread mt1 = new MyThread("Событийный Поток 1", evtObj);Console.WriteLine("Основной поток ожидает событие.");// Ожидать уведомления о событии.evtObj.WaitOne();Console.WriteLine("Основной поток получил " +"уведомление о событии от первого потока.");// Установить событийный объект в исходное состояние.evtObj.Reset();mt1 = new MyThread("Событийный Поток 2", evtObj);// Ожидать уведомления о событии.evtObj.WaitOne();Console.WriteLine("Основной поток получил " +"уведомление о событии от второго потока.");}}Ниже приведен результат выполнения рассматриваемой здесь программы, хотя увас он может оказаться несколько иным.В потоке Событийный Поток 1Событийный Поток 1Основной поток ожидает событие.Событийный Поток 1Событийный Поток 1Событийный Поток 1Событийный Поток 1Событийный Поток 1 завершен!Основной поток получил уведомление о событии от первого потока.В потоке Событийный Поток 2Событийный Поток 2Событийный Поток 2Событийный Поток 2Событийный Поток 2Событийный Поток 2Событийный Поток 2 завершен!Основной поток получил уведомление о событии от второго потока.Прежде всего обратите внимание на то, что событие типа ManualResetEventпередается непосредственно конструктору класса MyThread. Когда завершается метод Run() из класса MyThread, он вызывает для событийного объекта метод Set(),устанавливающий этот объект в сигнальное состояние. В методе Main() формируется событийный объект evtObj типа ManualResetEvent, первоначально устанавливаемый в исходное, несигнальное состояние. Затем создается экземпляр объекта типаMyThread, которому передается событийный объект evtObj. После этого основнойпоток ожидает уведомления о событии. А поскольку событийный объект evtObj первоначально находится в несигнальном состоянии, то основной поток вынужден ожидать до тех пор, пока для экземпляра объекта типа MyThread не будет вызван методSet(), устанавливающий событийный объект evtObj в сигнальное состояние. Этодает возможность основному потоку возобновить свое выполнение. Затем событийныйобъект устанавливается в исходное состояние, и весь процесс повторяется, но на этотраз для второго потока. Если бы не событийный объект, то все потоки выполнялисьбы одновременно, а результаты их выполнения оказались бы окончательно запутанными. Для того чтобы убедиться в этом, попробуйте закомментировать вызов методаWaitOne() в методе Main().Если бы в рассматриваемой здесь программе событийный объект типаAutoResetEvent использовался вместо событийного объекта типа ManualResetEvent,то вызывать метод Reset() в методе Main() не пришлось бы. Ведь в этом случае событийный объект автоматически устанавливается в несигнальное состояние, когда поток, ожидающий данное событие, возобновляет свое выполнение. Для опробованияэтой разновидности события замените в данной программе все ссылки на объект типаManualResetEvent ссылками на объект типа AutoResetEvent и удалите все вызовы метода Reset(). Видоизмененная версия программы будет работать так же, как и прежде.Класс InterlockedЕще одним классом, связанным с синхронизацией, является класс Interlocked.Этот класс служит в качестве альтернативы другим средствам синхронизации, когдатребуется только изменить значение общей переменной. Методы, доступные в классеInterlocked, гарантируют, что их действие будет выполняться как единая, непрерываемая операция. Это означает, что никакой синхронизации в данном случае вообщене требуется. В классе Interlocked предоставляются статические методы для сложения двух целых значений, инкрементирования и декрементирования целого значения,сравнения и установки значений объекта, обмена объектами и получения 64-разрядно-го значения. Все эти операции выполняются без прерывания.В приведенном ниже примере программы демонстрируется применение двух методов из класса Interlocked:Increment() и Decrement(). При этом используютсяследующие формы обоих методов:public static int Increment(ref int location)public static int Decrement(ref int location)где location — это переменная, которая подлежит инкрементированию или декрементированию.// Использовать блокируемые операции.using System;using System.Threading;// Общий ресурс.class SharedRes {public static int Count = 0;}// В этом потоке переменная SharedRes.Count инкрементируется.class IncThread {public Thread Thrd;public IncThread(string name) {Thrd = new Thread(this.Run);Thrd.Name = name;Thrd.Start();}// Точка входа в поток.void Run() {for(int i=0; i<5; i++) {Interlocked.Increment(ref SharedRes.Count);Console.WriteLine(Thrd.Name + " Count = " + SharedRes.Count);}}}// В этом потоке переменная SharedRes.Count декрементируется.class DecThread {public Thread Thrd;public DecThread(string name) {Thrd = new Thread(this.Run);Thrd.Name = name;Thrd.Start();}// Точка входа в поток.void Run() {for(int i=0; i<5; i++) {Interlocked.Decrement(ref SharedRes.Count);Console.WriteLine(Thrd.Name + " Count = " + SharedRes.Count);}}}class InterlockedDemo {static void Main() {// Сконструировать два потока.IncThread mt1 = new IncThread("Инкрементирующий Поток");DecThread mt2 = new DecThread("Декрементирующий Поток");mt1.Thrd.Join();mt2.Thrd.Join();}}Классы синхронизации, внедренные в версии .NET Framework 4.0Рассматривавшиеся ранее классы синхронизации, в том числе Semaphore иAutoResetEvent, были доступны в среде .NET Framework, начиная с версии 1.1.Таким образом, эти классы образуют основу поддержки синхронизации в среде .NETFramework. Но после выпуска версии .NET Framework 4.0 появился ряд новых альтернатив этим классам синхронизации. Все они перечисляются ниже.Класс НазначениеBarrier Вынуждает потоки ожидать появления всех остальных потоков в указанной точке, называемой барьернойCountdownEvent Выдает сигнал, когда обратный отсчет завершаетсяManualResetEventSlim Это упрощенный вариант класса ManualResetEventSemaphoreSlim Это упрощенный вариант класса SemaphoreЕсли вам понятно, как пользоваться основными классами синхронизации, описанными ранее в этой главе, то у вас не должно возникнуть затруднений при использовании их новых альтернатив и дополнений.Прерывание потокаИногда поток полезно прервать до его нормального завершения. Например, отладчику может понадобиться прервать вышедший из-под контроля поток. После прерывания поток удаляется из системы и не может быть начат снова.Для прерывания потока до его нормального завершения служит метод Thread.Abort(). Ниже приведена простейшая форма этого метода.public void Abort()Метод Abort() создает необходимые условия Для генерирования исключенияThreadAbortException в том потоке, для которого он был вызван. Это исключениеприводит к прерыванию потока и может быть перехвачено и в коде программы, нов этом случае оно автоматически генерируется еще раз, чтобы остановить поток. Метод Abort() не всегда способен остановить поток немедленно, поэтому если потоктребуется остановить перед тем, как продолжить выполнение программы, то послеметода Abort() следует сразу же вызвать метод Join(). Кроме того, в самых редкихслучаях методу Abort() вообще не удается остановить поток. Это происходит, например, в том случае, если кодовый блок finally входит в бесконечный цикл.В приведенном ниже примере программы демонстрируется применение методаAbort() для прерывания потока.// Прервать поток с помощью метода Abort().using System;using System.Threading;class MyThread {public Thread Thrd;public MyThread(string name) {Thrd = new Thread(this.Run);Thrd.Name = name;Thrd.Start();}// Это точка входа в поток.void Run() {Console.WriteLine(Thrd.Name + " начат.");for(int i = 1; i <= 1000; i++) {Console.Write(i + " ");if((i%10)==0) {Console.WriteLine();Thread.Sleep(250);}}Console.WriteLine(Thrd.Name + " завершен.");}}class StopDemo {static void Main() {MyThread mt1 = new MyThread("Мой Поток");Thread.Sleep(1000); // разрешить порожденному потоку начать свое выполнениеConsole.WriteLine("Прерывание потока.");mt1.Thrd.Abort();mt1.Thrd.Join(); // ожидать прерывания потокаConsole.WriteLine("Основной поток прерван.");}}Вот к какому результату приводит выполнение этой программы.Мой Поток начат1 2 3 4 5 6 7 8 9 1011 12 13 14 15 16 17 18 19 2021 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40Прерывание потока.Основной поток прерван.ПРИМЕЧАНИЕМетод Abort() не следует применять в качестве обычного средства прерывания потока,поскольку он предназначен для особых случаев. Обычно поток должен завершаться естественным образом, чтобы произошел возврат из метода, выполняющего роль точки входа в него.Другая форма метода Abort()В некоторых случаях оказывается полезной другая форма метода Abort(), приведенная ниже в общем виде:public void Abort (object stateInfo)где stateInfo обозначает любую информацию, которую требуется передать потоку, когда он останавливается. Эта информация доступна посредством свойстваExceptionState из класса исключения ThreadAbortException. Подобным образомпотоку можно передать код завершения. В приведенном ниже примере программыдемонстрируется применение данной формы метода Abort().// Использовать форму метода Abort (object stateInfo).using System;using System.Threading;class MyThread {public Thread Thrd;public MyThread(string name) {Thrd = new Thread(this.Run);Thrd.Name = name;Thrd.Start();}// Это точка входа в поток.void Run() {try {Console.WriteLine(Thrd.Name + " начат.");for (int i = 1; i <= 1000; i++) {Console.Write(i + " ");if((i%10)==0) {Console.WriteLine();Thread.Sleep(250);}}Console.WriteLine(Thrd.Name + " завершен нормально.");} catch(ThreadAbortException exc) {Console.WriteLine("Поток прерван, код завершения " +exc.ExceptionState);}}}class UseAltAbort {static void Main() {MyThread mt1 = new MyThread("Мой Поток");Thread.Sleep(1000); // разрешить порожденному потоку начать свое выполнениеConsole.WriteLine("Прерывание потока.");mt1.Thrd.Abort (100);mt1.Thrd.Join(); // ожидать прерывания потокаConsole.WriteLine("Основной поток прерван.");}}Эта программа дает следующий результат.Мой Поток начат1 2 3 4 5 6 7 8 9 1011 12 13 14 15 16 17 18 19 2021 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40Прерывание потока.Поток прерван, код завершения 100Основной поток прерван.Как следует из приведенного выше результата, значение 100 передается методуAbort() в качестве кода прерывания. Это значение становится затем доступным посредством свойства ExceptionState из класса исключения ThreadAbortException,которое перехватывается потоком при его прерывании.Отмена действия метода Abort()Запрос на преждевременное прерывание может быть переопределен в самом потоке. Для этого необходимо сначала перехватить в потоке исключениеThreadAbortException, а затем вызвать метод ResetAbort(). Благодаря этомуисключается повторное генерирование исключения по завершении обработчика исключения, прерывающего данный поток. Ниже приведена форма объявления методаResetAbort().public static void ResetAbort()Вызов метода ResetAbort() может завершиться неудачно, если в потоке отсутствует надлежащий режим надежной отмены преждевременного прерывания потока.В приведенном ниже примере программы демонстрируется применение методаResetAbort().// Использовать метод ResetAbort().using System;using System.Threading;class MyThread {public Thread Thrd;public MyThread(string name) {Thrd = new Thread(this.Run);Thrd.Name = name;Thrd.Start();}// Это точка входа в поток.void Run() {Console.WriteLine(Thrd.Name + ".начат.");for(int i = 1; i <= 1000; i++) {try {Console.Write(i + " ");if((i%10)==0) {Console.WriteLine();Thread.Sleep(250);}} catch(ThreadAbortException exc) {if((int)exc.ExceptionState == 0) {Console.WriteLine("Прерывание потока отменено! " +"Код завершения " + exc.ExceptionState);Thread.ResetAbort();}elseConsole.WriteLine("Поток прерван, код завершения " +exc.ExceptionState);}}Console.WriteLine(Thrd.Name + " завершен нормально.");}}class ResetAbort {static void Main() {MyThread mt1 = new MyThread("Мой Поток");Thread.Sleep(1000); // разрешить порожденному потоку начать свое выполнениеConsole.WriteLine("Прерывание потока.");mt1.Thrd.Abort(0); // это не остановит потокThread.Sleep(1000); // разрешить порожденному потоку выполняться подольшеConsole.WriteLine("Прерывание потока.");mt1.Thrd.Abort(100); // а это остановит потокmt1.Thrd.Join(); // ожидать прерывания потокаConsole.WriteLine("Основной поток прерван.");}}Ниже приведен результат выполнения этой программы.Мой Поток начат1 2 3 4 5 6 7 8 9 1011 12 13 14 15 16 17 18 19 2021 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40Прерывание потока.Прерывание потока отменено! Код завершения 041 42 43 44 45 46 47 48 49 5051 52 53 54 55 56 57 58 59 6061 62 63 64 65 66 67 68 69 7071 72 73 74 75 76 77 78 79 80Поток прерван, код завершения 100Основной поток прерван.Если в данном примере программы метод Abort() вызывается с нулевым аргументом, то запрос на преждевременное прерывание отменяется потоком, вызывающимметод ResetAbort(), и выполнение этого потока продолжается. Любое другое значение аргумента приведет к прерыванию потока.Приостановка и возобновление потокаВ первоначальных версиях среды .NET Framework поток можно было приостановить вызовом метода Thread.Suspend() и возобновить вызовом метода Thread.Resume(). Но теперь оба эти метода считаются устаревшими и не рекомендуются кприменению в новом коде. Объясняется это, в частности, тем, что пользоваться методом Suspend() на самом деле небезопасно, так как с его помощью можно приостановить поток, который в настоящий момент удерживает блокировку, что препятствуетее снятию, а следовательно, приводит к взаимоблокировке. Применение обоих методов может стать причиной серьезных осложнений на уровне системы. Поэтому дляприостановки и возобновления потока следует использовать другие средства синхронизации, в том числе мьютекс и семафор.Определение состояния потокаСостояние потока может быть получено из свойства ThreadState, доступного вклассе Thread. Ниже приведена общая форма этого свойства.public ThreadState ThreadState{ get; }Состояние потока возвращается в виде значения, определенного в перечисленииThreadState. Ниже приведены значения, определенные в этом перечислении.ThreadState.Aborted ThreadState.AbortRequestedThreadState.Background ThreadState.RunningThreadState.Stopped ThreadState.StopRequestedThreadState.Suspended ThreadState.SuspendRequestedThreadState.Unstarted ThreadState.WaitSleepJoinВсе эти значения не требуют особых пояснений, за исключением одного. ЗначениеThreadState.WaitSleepJoin обозначает состояние, в которое поток переходит вовремя ожидания в связи с вызовом метода Wait(), Sleep() или Join().Применение основного потокаКак пояснялось в самом начале этой главы, у всякой программы на C# имеется хотябы один поток исполнения, называемый основным. Этот поток программа получаетавтоматически, как только начинает выполняться. С основным потоком можно обращаться таким же образом, как и со всеми остальными потоками.Для доступа к основному потоку необходимо получить объект типа Thread, который ссылается на него. Это делается с помощью свойства CurrentThread, являющегося членом класса Thread. Ниже приведена общая форма этого свойства.public static Thread CurrentThread{ get; }Данное свойство возвращает ссылку на тот поток, в котором оно используется. Поэтому если свойство CurrentThread используется при выполнении кода в основномпотоке, то с его помощью можно получить ссылку на основной поток. Имея в своемраспоряжении такую ссылку, можно управлять основным потоком так же, как и любым другим потоком.В приведенном ниже примере программы сначала получается ссылка на основнойпоток, а затем получаются и устанавливаются имя и приоритет основного потока.// Продемонстрировать управление основным потоком.using System;using System.Threading;class UseMain {static void Main() {Thread Thrd;// Получить основной поток.Thrd = Thread.CurrentThread;// Отобразить имя основного потока.if(Thrd.Name == null)Console.WriteLine("У основного потока нет имени.");elseConsole.WriteLine("Основной поток называется: " + Thrd.Name);// Отобразить приоритет основного потока.Console.WriteLine("Приоритет: " + Thrd.Priority);Console.WriteLine();// Установить имя и приоритет.Console.WriteLine("Установка имени и приоритета.n");Thrd.Name = "Основной Поток";Thrd.Priority = ThreadPriority.AboveNormal;Console.WriteLine("Теперь основной поток называется: " +Thrd.Name);Console.WriteLine("Теперь приоритет: " + Thrd.Priority);}}Ниже приведен результат выполнения этой программы.У основного потока нет имени.Приоритет: NormalУстановка имени и приоритета.Теперь основной поток называется: Основной ПотокТеперь приоритет: AboveNormalСледует, однако, быть очень внимательным, выполняя операции с основным потоком. Так, если добавить в конце метода Main() следующий вызов метода Join():Thrd.Join();программа никогда не завершится, поскольку она будет ожидать окончания основногопотока!Дополнительные средства многопоточной обработки,внедренные в версии .NET Framework 4.0В версии .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 на экране появляется заключительное сообщение "Новый процесс завершен.".