простоя)
В первой форме ожидание длится вплоть до уведомления об освобождении объек
та, а во второй форме — как до уведомления об освобождении объекта, так и до ис
течения периода времени, на который указывает количество миллисекундпростоя.
В обеих формах 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 происходит, скорее, беспорядоч
но, чем последовательно.
Мьютекс, созданный в предыдущем примере, известен только тому процессу, кото
рый его породил. Но мьютекс можно создать и таким образом, чтобы он