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