Книга: C# 4.0: полное руководство

Класс Thread

Класс 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 MultiThreadlmproved {

  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
.....В потоке Потомок #2, Count = 2
В потоке Потомок #1, Count = 2
В потоке Потомок #3, Count = 2
....В потоке Потомок #3, Count = 3
В потоке Потомок #1, Count = 3
В потоке Потомок #2, Count = 3
.....В потоке Потомок #2, Count = 4
В потоке Потомок #1, Count = 4
В потоке Потомок #3, Count = 4
.....В потоке Потомок #2, Count = 5
В потоке Потомок #3, Count = 5
В потоке Потомок #1, Count = 5
.....В потоке Потомок #3, Count = 6
В потоке Потомок #1, Count = 6
В потоке Потомок #2, Count = 6
....В потоке Потомок #1, Count = 7
В потоке Потомок #2, Count = 7
В потоке Потомок #3, Count = 7
.....В потоке Потомок #3, Count = 8
В потоке Потомок #1, Count = 8
В потоке Потомок #2, Count = 8
.....В потоке Потомок #3, Count = 9
Потомок #3 завершен.
В потоке Потомок #2, Count = 9
Потомок #2 завершен.
В потоке Потомок #1, Count = 9
Потомок #1 завершен.
Основной поток завершен.

Как видите, после того как все три потока начнут выполняться, они будут совместно использовать ЦП. Приведенный выше результат может отличаться в зависимости от среды выполнения, операционной системы и других внешних факторов, влияющих на выполнение программы.

Оглавление книги