Сохранение порядка в PLINQ

В PLINQ цель — повысить производительность при сохранении правильности. Запрос должен выполняться как можно быстрее, но по-прежнему получать правильные результаты. В некоторых случаях правильность требует сохранения порядка исходной последовательности; однако порядок может быть дорогостоящим. Поэтому по умолчанию PLINQ не сохраняет порядок исходной последовательности. В этом отношении PLINQ напоминает LINQ to SQL, но в отличие от LINQ to Objects, который сохраняет порядок.

Чтобы переопределить поведение по умолчанию, можно включить сохранение порядка с помощью AsOrdered оператора в исходной последовательности. Затем вы можете отключить сохранение заказа позже в запросе AsUnordered с помощью метода. При использовании обоих методов запрос обрабатывается на основе эвристики, которая определяет, следует ли выполнять запрос как параллельный или последовательный. Дополнительные сведения см. "Понимание ускорения в PLINQ".

В следующем примере показан неупорядоченный параллельный запрос, который фильтрует все элементы, соответствующие условию, без попытки упорядочить результаты каким-либо образом.

var cityQuery =
    (from city in cities.AsParallel()
     where city.Population > 10000
     select city).Take(1000);

Dim cityQuery = From city In cities.AsParallel()
                Where city.Population > 10000
                Take (1000)

Этот запрос не обязательно создает первые 1000 городов в исходной последовательности, которые соответствуют условию, а скорее некоторые из 1000 городов, которые соответствуют условию. Операторы запросов PLINQ разбивают исходную последовательность на несколько подпоследовательностей, которые обрабатываются как одновременные задачи. Если сохранение порядка не указано, результаты каждого раздела передаются на следующий этап запроса в произвольном порядке. Кроме того, раздел может предоставить подмножество своих результатов, прежде чем продолжить обработку оставшихся элементов. Результирующий порядок может отличаться каждый раз. Приложение не может контролировать это, так как оно зависит от того, как операционная система планирует потоки.

Следующий пример переопределяет поведение по умолчанию с помощью AsOrdered оператора в исходной последовательности. Это гарантирует, что Take метод возвращает первые 1000 городов в исходной последовательности, удовлетворяющей условию.

var orderedCities =
    (from city in cities.AsParallel().AsOrdered()
     where city.Population > 10000
     select city).Take(1000);

Dim orderedCities = From city In cities.AsParallel().AsOrdered()
                    Where city.Population > 10000
                    Take (1000)

Однако этот запрос, вероятно, не выполняется так быстро, как неупорядоченная версия, так как ему необходимо отслеживать исходное упорядочение через разделы и во время слияния гарантировать согласованность упорядочения. Поэтому рекомендуется использовать AsOrdered только в тех случаях, когда это необходимо, и только для тех частей запроса, которые требуют его. Если сохранение порядка больше не требуется, используйте AsUnordered, чтобы его отключить. В следующем примере это достигается путем создания двух запросов.

var orderedCities2 =
    (from city in cities.AsParallel().AsOrdered()
     where city.Population > 10000
     select city).Take(1000);

var finalResult =
    from city in orderedCities2.AsUnordered()
    join p in people.AsParallel()
    on city.Name equals p.CityName into details
    from c in details
    select new
    {
        city.Name,
        Pop = city.Population,
        c.Mayor
    };

foreach (var city in finalResult) { /*...*/ }

Dim orderedCities2 = From city In cities.AsParallel().AsOrdered()
                     Where city.Population > 10000
                     Select city
                     Take (1000)

Dim finalResult = From city In orderedCities2.AsUnordered()
                  Join p In people.AsParallel() On city.Name Equals p.CityName
                  Select New With {.Name = city.Name, .Pop = city.Population, .Mayor = city.Mayor}

For Each city In finalResult
    Console.WriteLine(city.Name & ":" & city.Pop & ":" & city.Mayor)
Next

Обратите внимание, что PLINQ сохраняет порядок последовательности, созданной операторами, налагающими порядок, в оставшейся части запроса. Другими словами, операторы, такие как OrderBy и ThenBy рассматриваются, как если бы за ними последовал вызов AsOrdered.

Операторы запросов и упорядочивание

Следующие операторы запросов вводят сохранение порядка во все последующие операции в запросе или до вызова AsUnordered:

• OrderBy

• OrderByDescending

• ThenBy

• ThenByDescending

В некоторых случаях следующие операторы запросов PLINQ могут потребовать упорядоченные исходные последовательности, чтобы получить правильные результаты.

• Reverse

• SequenceEqual

• TakeWhile

• SkipWhile

• Zip

Некоторые операторы запросов PLINQ ведут себя по-разному в зависимости от того, упорядочена ли их исходная последовательность или неупорядочена. В следующей таблице перечислены эти операторы.

Неупорядоченные результаты не активно перетасовываются; Они просто не имеют специальной логики упорядочения, примененной к ним. В некоторых случаях неупорядоченный запрос может сохранить порядок исходной последовательности. Для запросов, использующих индексируемый оператор Select, PLINQ гарантирует, что выходные элементы будут выходить в порядке увеличения индексов, но не гарантирует, какие индексы будут назначены элементам.

См. также

• Parallel LINQ (PLINQ)
• Параллельное программирование