кой из потоков завершится первым. Возни
кающее состояние гонок, как и взаимоблокировку, непросто обнаружить. Поэтому его
лучше предотвратить, синхронизируя должным образом доступ к общим ресурсам
при программировании.
Применение атрибута 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(). В противном случае выполнение вызывающего потока
приостанавливается до тех пор, пока не будет получено уведомление о событии. Как
только событие произойд