Следует, однако, иметь в виду, что далеко не все циклы могут выполняться эффективно, когда они распараллеливаются. Как правило, мелкие циклы, а также циклы, состоящие из очень простых операций, выполняются быстрее последовательным способом, чем параллельным. Именно поэтому цикл for инициализации массива данных не распараллеливается методом For() в рассматриваемой здесь программе. Распараллеливание мелких и очень простых циклов может оказаться неэффективным потому, что время, требующееся для организации параллельных задач, а также время, расходуемое на переключение контекста, превышает время, экономящееся благодаря параллелизму. В подтверждение этого факта в приведеннрм ниже примере программы создаются последовательный и параллельный варианты цикла for, а для сравнения на экран выводится время выполнения каждого из них.
// Продемонстрировать отличия во времени последовательного
//и параллельного выполнения цикла for.
using System;
using System.Threading.Tasks;
using System.Diagnostics;
class DemoParallelFor {
static int[] data;
// Метод, служащий в качестве тела параллельно выполняемого цикла.
// Операторы этого цикла просто расходуют время ЦП для целей демонстрации,
static void MyTransform(int i) {
data[i] = data[i] / 10;
if(data[i] < 1000) data[i] = 0;
if(data[i] > 1000 & data[i] < 2000) data[i] = 100;
if(data[i] > 2000 & data[i] < 3000) data[i] = 200;
if(data[i] > 3000) data[i] = 300;
}
static void Main() {
Console.WriteLine("Основной поток запущен.");
// Create экземпляр объекта типа Stopwatch
// для хранения времени выполнения цикла.
Stopwatch sw = new Stopwatch();
data = new int[100000000];
// Инициализировать данные,
sw.Start();
// Параллельный вариант инициализации массива в цикле.
Parallel.For(0, data.Length, (i) => data[i] = i );
sw.Stop();
Console.WriteLine("Параллельно выполняемый цикл инициализации: " +
"{0} секунд", sw.Elapsed.TotalSeconds);
sw.Reset();
sw.Start();
// Последовательный вариант инициализации массива в цикле,
for(int i=0; i < data.Length; i++) data[i] = i;
sw.Stop();
Console.WriteLine("Последовательно выполняемый цикл инициализации: " +
"{0} секунд", sw.Elapsed.TotalSeconds);
Console.WriteLine();
// Выполнить преобразования,
sw.Start();
// Параллельный вариант преобразования данных в цикле.
Parallel.For(0, data.Length, MyTransform);
sw.Stop();
Console.WriteLine("Параллельно выполняемый цикл преобразования: " +
"{0} секунд", sw.Elapsed.TotalSeconds);
sw.Reset();
sw.Start();
// Последовательный вариант преобразования данных в цикле,
for(int i=0; i < data.Length; i++) MyTransform(i);
sw.Stop();
Console.WriteLine("Последовательно выполняемый цикл преобразования: " +
"{0} секунд", sw.Elapsed.TotalSeconds);
Console.WriteLine("Основной поток завершен.");
}
}
При выполнении этой программы на двухъядерном компьютере получается следующий результат.
Основной поток запущен.
Параллельно выполняемый цикл инициализации: 1.0537757 секунд
Последовательно выполняемый цикл инициализации: 0.3457628 секунд
Параллельно выполняемый цикл преобразования: 4.2246675 секунд
Последовательно выполняемый цикл преобразования: 5.3849959 секунд
Основной поток завершен.
Прежде всего, обратите внимание на то, что параллельный вариант цикла инициализации массива данных выполняется приблизительно в три раза медленнее, чем последовательный. Дело в том, что в данном случае на операцию присваивания расходуется так мало времени, что издержки на дополнительно организуемое распараллеливание превышают экономию, которую оно дает. Обратите далее внимание на то, что параллельный вариант цикла преобразования данных выполняется быстрее, чем последовательный. В данном случае экономия от распараллеливания с лихвой возмещает издержки на его дополнительную организацию.
----------------------------------
ПРИМЕЧАНИЕ
Как правило, в отношении преимуществ, которые дает распараллеливание различных видов циклов, следует руководствоваться текущими рекомендациями корпорации Microsoft. Кроме того, необходимо убедиться в том, что распараллеливание цикла действительно приводит к повышению производительности, прежде чем использовать такой цикл в окончательно выпускаемом прикладном коде.
----------------------------------
Что касается приведенной выше программы, то необходимо упомянуть о двух других ее особенностях. Во-первых, обратите внимание на то, что в параллельно выполняемом цикле для инициализации данных применяется лямбда-выражение, как показано ниже.
Parallel.For(0, data.Length, (i) => data[i] = i );
Здесь "тело" цикла указывается в лямбда-выражении. (Напомним, что в лямбда-выражении создается анонимный метод.) Следовательно, для параллельного выполнения методом For() совсем не обязательно указывать именованный метод.
И во-вторых, обратите внимание на применение класса Stopwatch для вычисления времени выполнения цикла. Этот класс находится в пространстве имен System.Diagnostics. Для того чтобы воспользоваться им, достаточно создать экземпляр его объекта, а затем вызвать метод Start(), начинающий отчет времени, и далее — метод Stop(), завершающий отсчет времени. А с помощью метода Reset() отсчет времени сбрасывается в исходное состояние. Продолжительность выполнения можно получить различными способами. В рассматриваемой здесь программе для этой цели использовано свойство Elapsed, возвращающее объект типа TimeSpan. С помощью этого объекта и свойства TotalSeconds время отображается в секундах, включая и доли секунды. Как показывает пример рассматриваемой здесь программы, класс Stopwatch оказывается весьма полезным при разработке параллельно исполняемого кода.
Как упоминалось выше, метод For() возвращает экземпляр объекта типа ParallelLoopResult. Это структура, в которой определяются два следующих свойства.
public bool IsCompleted { get; }
public Nullable<long> LowestBreaklteration { get; }
Свойство IsCompleted будет иметь логическое значение true, если выполнены все шаги цикла. Иными словами, при нормальном завершении цикла это свойство будет содержать логическое значение true. Если же выполнение цикла прервется раньше времени, то данное свойство будет содержать логическое значение false. Свойство LowestBreaklteration будет содержать наименьшее значение переменной управления циклом, если цикл прервется раньше времени вызовом метода ParallelLoopState.Break().
Для доступа к объекту типа ParallelLoopState следует использовать форму метода For(), делегат которого принимает в качестве второго параметра текущее состояние цикла. Ниже эта форма метода For() приведена в простейшем виде.
public static ParallelLoopResult For(int fromlnclusive, int toExclusive,
Action<int, ParallelLoopState> body)
В данной форме делегат Action, описывающий тело цикла, определяется следующим образом.
public delegate void Action<in T1, in T2>(T arg1, T2 arg2)
Для метода For() обобщенный параметр T1 должен быть типа int, а обобщенный параметр Т2 — типа ParallelLoopState. Всякий раз, когда делегат Action вызывается, текущее состояние цикла передается в качестве аргумента arg2.
Для преждевременного завершения цикла следует воспользоваться методом Break(), вызываемым для экземпляра объекта типа ParallelLoopState внутри тела цикла, определяемого параметром body. Метод Break() объявляется следующим образом.
