На этом шаге мы рассмотрим еще один пример использования потоков.

    В следующей программе создается двумерный числовой массив, и этот массив построчно заполняется. Заполнение каждой строки выполняется отдельным потоком. Объектные переменные, через которые реализуются ссылки на потоки, организованы в массив. Это общая идея. Далее рассмотрим способ ее реализации. Интересующий нас программный код представлен в тексте ниже.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Threading;

namespace pr245_1
{
    class Program
    {
        // Главный метод: 
        static void Main()
        {
            // Двумерный массив: 
            int[,] nums = new int[6, 9];
            // Массив из объектных переменных для потоков:
            Thread[] t = new Thread[nums.GetLength(0)];
            // Перебор элементов массива: 
            for(int i = 0; i < t.Length; i++) {
                // Локальная переменная для цикла: 
                int p = i;
                // Создание объекта потока: 
                t[i] = new Thread(()=> {
                    // Перебор элементов в строке
                    // целочисленного массива: 
                    for(int j = 0; j < nums.GetLength(1); j++) {
                        // Элементу присваивается значение: 
                        nums[p, j] = (p + 1) * (j + 1);
                        // Приостановка выполнения потока:
                        Thread.Sleep(100);
                    }
                });
                // Запуск потока на выполнение: 
                t[i].Start();
            }
            
            // Ожидание завершения дочерних потоков: 
            for(int i = 0; i < t.Length; i++) { 
                if (t[i].IsAlive) t[i].Join();
            }

            // Отображение содержимого двумерного целочисленного 
            // массива:
            for (int i = 0; i < nums.GetLength(0); i++)
            {
                for (int j = 0; j < nums.GetLength(1); j++)
                {
                    Console.Write("{0,-4}", nums[i, j]);
                }
                Console.WriteLine();
            }
        }
    }
}

    Результат выполнения программы представлен ниже:

Рис.1. Результат работы приложения

    Мы создаем двумерный целочисленный массив nums. Еще мы создаем массив t из объектных переменных класса Thread. Размер массива t равен количеству строк в массиве nums (вычисляется инструкцией nums.GetLength(0)). После этого перебираются элементы массива t, и на каждой итерации цикла при фиксированном индексе i выполняются такие команды:

• Объявляется локальная целочисленная переменная p, и в качестве значения ей присваивается текущее значение индекса i. Важно, что переменная объявляется внутри цикла. Поэтому переменная создается (под нее выделяется место в памяти) за каждый цикл заново. По идее, область доступности и время существования этой переменной определяются циклом. Но как мы увидим далее, на эту переменную будет ссылаться метод, реализуемый через лямбда-выражение (используется при создании потока). Поэтому переменная p будет существовать, пока работает поток. Но самое важное то, что у каждого потока будет "своя" переменная p.

• Создается объект потока. При создании объекта класса Thread (объект потока, ссылка на который записывается в элемент t[i]) аргументом конструктору передается лямбда-выражение, определяющее метод, выполняемый в потоке. Этим методом запускается конструкция цикла, в котором переменная j пробегает значения второго индекса для элементов массива nums, при условии, что первый индекс равен p. Командой

    nums[p, j] = (p+1)*(j + 1); 
  

  соответствующему элементу присваивается значение (то есть значение элемента равно произведению порядкового номера строки на порядковый номер столбца). После присваивания значения элементу целочисленного массива командой

    Thread.Sleep(100); 
  

  делается небольшая пауза в выполнении потока.

• После создания объекта потока командой

    t[i].Start(); 
  

  этот поток запускается на выполнение.

    Таким образом, после выполнения конструкции цикла будут запущены дочерние потоки. Количество дочерних потоков равно количеству строк в двумерном массиве. Ссылки на объекты потоков записаны в массив t. Каждый поток заполняет одну строку двумерного массива.

Несложно заметить, что переменная p фактически дублирует переменную i в конструкции цикла. Почему нельзя было вместо p использовать i? Переменная p для каждого цикла своя. Переменная i для всех циклов общая. Если бы в лямбда-выражении вместо переменной p использовалась переменная i, то методы, выполняемые в разных потоках, ссылались бы на одну и ту же переменную i, которая изменяет свое значение в процессе выполнения цикла. Выполнение кода становится непредсказуемым - точнее, предсказуемо заканчивается ошибкой.

    Далее по плану содержимое массива должно отображаться в консольном окне. Но для этого главный поток должен дождаться окончания выполнения дочерних потоков. Поэтому запускается конструкция цикла, в которой перебираются все элементы из массива t. На каждой итерации цикла для данного индекса i проверяется условие t[i].IsAlive. Если оно истинно (поток продолжает работу), то ожидается завершение потока (команда

  t[i].Join();

Инструкция {0,-4} в строке форматирования в методе WriteLine() означает, что под соответствующий аргумент при отображении в консольном окне отводится 4 позиции, а выравнивание выполняется по левому краю (поскольку второе число отрицательное).

    На следующем шаге мы продолжим изучение этого вопроса.

Предыдущий шаг Содержание Следующий шаг