Skip to content

Add race condition examples to PLINQ shared memory pitfalls section #51523

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
Copilot wants to merge 4 commits into
base: main
Choose a base branch
from
+112 −0
Draft

Add race condition examples to PLINQ shared memory pitfalls section #51523

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
b885b57
Initial plan
Copilot Feb 5, 2026
471f1f7
Add race condition examples to PLINQ documentation
Copilot Feb 5, 2026
4d7ba36
Remove unused using directives from race condition examples
Copilot Feb 5, 2026
e5c02ad
Disable ImplicitUsings for explicit namespace clarity in examples
Copilot Feb 5, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 16 additions & 0 deletions docs/standard/parallel-programming/potential-pitfalls-with-plinq.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,6 +22,22 @@ Parallelization sometimes causes a PLINQ query to run slower than its LINQ to Ob

In sequential code, it is not uncommon to read from or write to static variables or class fields. However, whenever multiple threads are accessing such variables concurrently, there is a big potential for race conditions. Even though you can use locks to synchronize access to the variable, the cost of synchronization can hurt performance. Therefore, we recommend that you avoid, or at least limit, access to shared state in a PLINQ query as much as possible.

### Example: Race condition with shared memory

The following example demonstrates a race condition that occurs when multiple threads write to a shared variable. The variable `total` is accessed concurrently by multiple threads without synchronization, leading to unpredictable results:

:::code language="csharp" source="./snippets/potential-pitfalls-with-plinq/csharp/RaceConditionExample/Program.cs" id="RaceConditionBad":::
:::code language="vb" source="./snippets/potential-pitfalls-with-plinq/vb/RaceConditionExample/Program.vb" id="RaceConditionBad":::

In this code, the operation `total += n` is not atomic. It involves reading the current value, adding `n`, and writing the result back. When multiple threads execute this operation simultaneously, they can read the same value, add to it, and write back results that overwrite each other. This causes some additions to be lost, producing an incorrect final result.

The correct approach is to use thread-safe operations that don't require shared mutable state:

:::code language="csharp" source="./snippets/potential-pitfalls-with-plinq/csharp/RaceConditionExample/Program.cs" id="RaceConditionGood":::
:::code language="vb" source="./snippets/potential-pitfalls-with-plinq/vb/RaceConditionExample/Program.vb" id="RaceConditionGood":::

The `Sum` method handles parallelization internally in a thread-safe manner, ensuring correct results without the need for explicit synchronization. Other safe approaches include using <xref:System.Linq.ParallelEnumerable.Aggregate%2A> for custom aggregations or collecting results into thread-safe collections like <xref:System.Collections.Concurrent.ConcurrentBag%601>.

## Avoid over-parallelization

By using the `AsParallel` method, you incur the overhead costs of partitioning the source collection and synchronizing the worker threads. The benefits of parallelization are further limited by the number of processors on the computer. There is no speedup to be gained by running multiple compute-bound threads on just one processor. Therefore, you must be careful not to over-parallelize a query.
Expand Down
41 changes: 41 additions & 0 deletions ...programming/snippets/potential-pitfalls-with-plinq/csharp/RaceConditionExample/Program.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,41 @@
using System;
using System.Linq;

class RaceConditionExample
{
static void Main()
{
Console.WriteLine("=== Race Condition Example ===");
DemonstrateRaceCondition();

Console.WriteLine("\n=== Fixed Version ===");
DemonstrateCorrectApproach();
}

// <RaceConditionBad>
static void DemonstrateRaceCondition()
{
int total = 0;
var numbers = Enumerable.Range(0, 10000);

// UNSAFE: Multiple threads writing to shared variable
numbers.AsParallel().ForAll(n => total += n);

Console.WriteLine($"Total (with race condition): {total}");
// Expected: 49,995,000 but result is unpredictable due to race condition
}
// </RaceConditionBad>

// <RaceConditionGood>
static void DemonstrateCorrectApproach()
{
var numbers = Enumerable.Range(0, 10000);

// SAFE: Use thread-safe aggregate operation
int total = numbers.AsParallel().Sum();

Console.WriteLine($"Total (correct): {total}");
// Result is always 49,995,000
}
// </RaceConditionGood>
}
9 changes: 9 additions & 0 deletions ...ets/potential-pitfalls-with-plinq/csharp/RaceConditionExample/RaceConditionExample.csproj
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,9 @@
<Project Sdk="Microsoft.NET.Sdk">

<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net10.0</TargetFramework>
<Nullable>enable</Nullable>
</PropertyGroup>

</Project>
37 changes: 37 additions & 0 deletions ...lel-programming/snippets/potential-pitfalls-with-plinq/vb/RaceConditionExample/Program.vb
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,37 @@
Imports System
Imports System.Linq

Class RaceConditionExample
Shared Sub Main()
Console.WriteLine("=== Race Condition Example ===")
DemonstrateRaceCondition()

Console.WriteLine(Environment.NewLine & "=== Fixed Version ===")
DemonstrateCorrectApproach()
End Sub

' <RaceConditionBad>
Shared Sub DemonstrateRaceCondition()
Dim total As Integer = 0
Dim numbers = Enumerable.Range(0, 10000)

' UNSAFE: Multiple threads writing to shared variable
numbers.AsParallel().ForAll(Sub(n) total += n)

Console.WriteLine($"Total (with race condition): {total}")
' Expected: 49,995,000 but result is unpredictable due to race condition
End Sub
' </RaceConditionBad>

' <RaceConditionGood>
Shared Sub DemonstrateCorrectApproach()
Dim numbers = Enumerable.Range(0, 10000)

' SAFE: Use thread-safe aggregate operation
Dim total As Integer = numbers.AsParallel().Sum()

Console.WriteLine($"Total (correct): {total}")
' Result is always 49,995,000
End Sub
' </RaceConditionGood>
End Class
9 changes: 9 additions & 0 deletions ...nippets/potential-pitfalls-with-plinq/vb/RaceConditionExample/RaceConditionExample.vbproj
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,9 @@
<Project Sdk="Microsoft.NET.Sdk">

<PropertyGroup>
<OutputType>Exe</OutputType>
<RootNamespace>RaceConditionExample</RootNamespace>
<TargetFramework>net10.0</TargetFramework>
</PropertyGroup>

</Project>