آموزش کامل Race Condition در سیشارپ — از صفر تا صد
⚡ خلاصه سریع — اصل کاریها
اینها مهمترین چیزهایی هستن که اگه هیچی ندونی، فقط اینا رو بدونی کافیه:
- نکته ۱: Race Condition یعنی دو یا چند Thread همزمان روی یک حافظه مشترک (مثلاً یک متغیر) کار میکنن و نتیجه به ترتیب اجراشون بستگی پیدا میکنه → خروجی غیرقابل پیشبینی میشه.
- نکته ۲: راه اولیه و سادهاش
lockهست. راههای سبکتر برای اعداد سادهInterlockedهست. - نکته ۳:-typeهای آماده مثل
ConcurrentDictionaryوConcurrentQueueبراتون Thread-Safety رو مدیریت میکنن. - نکته ۴:
async/awaitبهتنهایی مشکل Race Condition رو حل نمیکنه؛ Thread هیجانی نیست ولی Race میتونه روی Thread-Pool و Contextها رخ بده. - نکته ۵: تست Race سخت است، ولی Timeline تعمیمیافته و Run زمانبندیهای مختلف میتونه کمک کنه.
- نکته ۶: ساختارهای Immutable و Copy-on-Write خطر Race رو از ریشه کم میکنن.
- نکته ۷:
volatileقفل نیست؛ فقط visibility کشهای CPU رو تضمین میکنه.
۳ اشتباه رایج:
- قفل کردن یک Object از نوع
stringیاTypeیاthis(Deadlock و کارایی پایین). - استفاده از
lockروی کل Dictionary و گمان کردن که این کافیه (دسترسیهای مرکب atomic نمیشن). - صدا زدن کد ناشناس در داخل
lock(например calling virtual method or event invocation → Deadlock).
اگر فقط ۵ دقیقه وقت داری:
- بدان Race Condition یعنی "اشتراک داده + تغییر همزمان + عدم هماهنگی".
- برای شمارندهها از
Interlocked.Incrementاستفاده کن. - برای ساختارهای داده از
ConcurrentDictionaryیاlockروی یکobjectخصوصی استفاده کن. - هرگز داخل
lockکدی که Call به بیرون میزنه ننویس. - کدت رو با تستهای موازی و کنترل نشده شرطito تست کن.
۱. مقدمه
سلام! توی این آموزش قراره یکی از مهمترین و در عین حال خفنترین مفاهیم برنامهنویسی موازی رو با هم یاد بگیریم: Race Condition (به فارسی: "وضعیت مسابقه" یا "شرایط رقابتی").
تعریف ساده: Race Condition زمانی رخ میدهد که دو یا چند Thread (ریسمان اجرایی) به یک منبع مشترک دسترسی دارند، حداقل یکی از آنها آن را تغییر میدهد و هیچ مکانیزم هماهنگی (Synchronization) بین آنها وجود ندارد. در نتیجه خروجی نهایی به ترتیب اجرای Thread ها بستگی پیدا میکند — یعنی غیرقوانین پیشبینی میشود.
یک مثال از زندگی روزمره
فرض کنید شما و همکارتان همزمان دارید یک فایل Excel مشترک رو ویرایش میکنید. هر دو در یک لحظه مقدار سلول A1 رو میخونید (مثلاً ۱۰۰۰). شما ۵۰۰ تا اضافه میکنید و ذخیره میکنید (۱۵۰۰). همکارتان هم ۲۰۰ تا اضافه میکنه و ذخیره میکنه (۱۲۰۰). نتیجه نهایی ۱۲۰۰ میشه در حالی که باید ۱۷۰۰ میشد! این دقیقاً Race Condition است.
چرا در سیشارپ مهم است؟
سیشارپ و داتنت بهطور ذاتی از چندنخی (Multi-threading) پشتیبانی میکنند:
- Thread Pool و
Taskها async/await- Parallel LINQ (PLINQ)
- Parallel.ForEach
هر جا موازیسازی باشه، احتمال Race Condition هم وجود داره.Race Condition یکی از مخفیترین باگهاست چون:
- معمولاً در تستهای تکنخی خودشون رو نشون نمیدن
- ممکنه هزار بار تست کنی و هیچ اتفاقی نیفته
- فقط تحت بار خاصی یا روی سختافزار خاصی رخ بده (CPU چند هستهای، Hyper-threading)
۲. پیشنیازها
برای درک کامل این آموزش، آشنایی نسبی با موارد زیر کمک میکنه (ولی من همه چیز رو از پایه توضیح میدم):
| مفهوم | سطح مورد نیاز | توضیح |
|---|---|---|
| C# پایه | متوسط | کلاس، متد، generic |
| LINQ | پایه | برای مثالهای.collection |
| delegate / event | پایه | برای درک callback ها |
| async/await | پایه | تفاوت Thread و Task |
| مفاهیم سیستمعامل | آشنایی مفهومی | Process, Thread, Memory |
نیاز ندارید: نسخههای قبلی داتنت رو بلد باشید، یا تجربه multi-threading داشته باشید.
۳. نصب و راهاندازی
برای اجرای مثالهای این آموزش فقط به یکی از موارد زیر نیاز دارید:
گزینه ۱: Visual Studio (پیشنهاد برای ویندوز)
- Visual Studio Community رو رایگان دانلود کنید.
- در زمان نصب، workload .NET desktop development یا ASP.NET رو انتخاب کنید.
گزینه ۲: VS Code (سبک و کراسپلتفرم)
- VS Code رو نصب کنید.
- افزونه C# Dev Kit رو نصب کنید.
گزینه ۳: فقط داتنت SDK (خط فرمان)
# دانلود از https://dotnet.microsoft.com/download
dotnet --version # بررسی نصب SDK
dotnet new console -o RaceConditionDemo
cd RaceConditionDemo
dotnet run
تنظیم پروژه برای مثالها
فایل .csproj شما باید حداقل این تنظیمات رو داشته باشه:
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<LangVersion>latest</LangVersion>
</PropertyGroup>
<!-- برای تستهای موازی در فصل ۱۳ -->
<ItemGroup>
<PackageReference Include="xunit" Version="2.6.*" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.5.*" />
</ItemGroup>
</Project>
💡 نکته: در پروژههای کنسول با .NET ۶ به بالا، نیازی به نوشتن
class Programوstatic void Mainنیست — Top-level Statements کافی است.
۴. مفاهیم پایه
قبل از اینکه وارد Race Condition بشیم، باید چند تا مفهوم رو محکم کنیم.
۴.۱. Process و Thread چیست؟
- Process (فرایند): یک برنامه در حال اجرا. هر Process حافظه خودش رو داره.
- Thread (نخ): کوچکترین واحد اجرایی داخل یک Process. تمام Thread های یک Process، حافظه مشترک دارند!
using System;
using System.Threading;
// هر دو Thread به یک متغیر مشترک دسترسی دارند
int sharedValue = 0;
var t1 = new Thread(() => { sharedValue++; });
var t2 = new Thread(() => { sharedValue++; });
t1.Start(); t2.Start();
t1.Join(); t2.Join();
Console.WriteLine(sharedValue); // گاهی ۱، گاهی ۲!
۴.۲. چرا ++ ساده نیست؟
عمل sharedValue++ یک عمل اتمیک (Atomic) نیست. در زبان ماشین به سه دستور تقسیم میشه:
| گام | دستور | توضیح |
|---|---|---|
| ۱ | READ |
مقدار فعلی رو از حافظه بخوان |
| ۲ | ADD |
یکی به مقدار اضافه کن (در CPU Register) |
| ۳ | WRITE |
مقدار جدید رو در حافظه بنویس |
سناریوی فاجعه:
| زمان | Thread ۱ | Thread ۲ | مقدار حافظه |
|---|---|---|---|
| T1 | READ (0) | 0 | |
| T2 | READ (0) | 0 | |
| T3 | ADD (1) | 0 | |
| T4 | ADD (1) | 0 | |
| T5 | WRITE (1) | 1 | |
| T6 | WRITE (1) | 1 |
نتیجه: ۱! در حالی که باید ۲ میشد. این یک Lost Update است.
۴.۳. تعریف رسمی Race Condition
طبق تعریف کلاسیک، سه شرط لازم برای Race Condition است:
- اشتراک داده (Sharing): دو یا چند Thread به یک منبع مشترک دسترسی دارند.
- تغییر (Mutation): حداقل یکی از Thread ها آن را تغییر میدهد (نه فقط خواندن).
- عدم هماهنگی (No Synchronization): هیچ مکانیزمی برای ترتیببندی دسترسیها وجود ندارد.
⚠️ نکته مهم: دو Thread که فقط میخونن مشکل Race Condition ندارن (البته با فرض عدم نوشتن همزمان). مشکل از جایی شروع میشه که حداقل یک Thread مینویسه.
۴.۴. انواع Race Condition
| نوع | توضیح | مثال |
|---|---|---|
| Data Race | دسترسی همزمان به یک متغیر | دو Thread که یک int رو increment میکنن |
| Logical Race | ترتیب منطقی اجرای Thread ها | Thread A یک لیست رو پاک میکنه در حالی که Thread B داره روش پارس میکنه |
| TOCTOU | Time-Of-Check to Time-Of-Use | if (cache == null) cache = Load(); و هر دو Thread چک میکنن |
| Check-then-Act | مشابه TOCTOU | if (!dict.ContainsKey(k)) dict.Add(k, v); |
۴.۵. مفهوم Thread-Safety
یک کد Thread-Safe است اگر با اجرای همزمان چند Thread، همچنان درست کار کند. Race Condition دلیل اصلی غیر Thread-Safe بودن کد است.
۵. مثالهای کد ساده
۵.۱. مثال ۱: باگ کلاسیک — Counter غیر امن
بریم اول باگ رو با چشم خودمون ببینیم:
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static int counter = 0; // متغیر مشترک
static void Main()
{
const int threadCount = 10;
const int incrementPerThread = 100_000;
var tasks = new List<Task>();
for (int i = 0; i < threadCount; i++)
{
tasks.Add(Task.Run(() =>
{
for (int j = 0; j < incrementPerThread; j++)
{
counter++; // ❌ عمل غیراتمیک!
}
}));
}
Task.WaitAll(tasks.ToArray());
int expected = threadCount * incrementPerThread;
Console.WriteLine($"Expected: {expected}"); // 1,000,000
Console.WriteLine($"Actual : {counter}"); // معمولاً کمتر!
Console.WriteLine($"Lost updates: {expected - counter}");
}
}
خروجی احتمالی:
Expected: 1000000
Actual : 873412
Lost updates: 126588
🎯 این نمونه بارز Race Condition است. هر بار اجرا کنید، عدد متفاوتی میبینید!
۵.۲. مثال ۲: باگ Check-then-Act (TOCTOU)
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
class Program
{
static Dictionary<int, string> cache = new();
static string GetOrAdd(int id)
{
// ❌ CHECK و ACT دو گام جداگانهاند
if (!cache.ContainsKey(id))
{
string value = LoadFromDatabase(id); // شبیهسازی
cache.Add(id, value); // ممکنه Thread دیگه هم الان همین کارو بکنه → Exception
}
return cache[id];
}
static string LoadFromDatabase(int id) => $"Data-{id}";
static void Main()
{
// ۱۰۰ Task همزمان که همشون میخوان کلید ۵ رو اضافه کنن
Parallel.For(0, 100, i => GetOrAdd(5));
Console.WriteLine($"Cache count: {cache.Count}"); // گاهی Exception، گاهی ۱
}
}
خروجی متناوباً یکی از این دو حالت است:
Cache count: 1
یا
System.ArgumentException: An item with the same key has already been added.
۵.۳. مثال ۳: اولین راه حل — lock
using System;
using System.Threading.Tasks;
class Program
{
static int counter = 0;
static readonly object lockObj = new object(); // شی قفل اختصاصی ✅
static void Main()
{
Parallel.For(0, 1_000_000, i =>
{
lock (lockObj)
{
counter++; // حالا امن است
}
});
Console.WriteLine($"Counter: {counter}"); // همیشه 1,000,000 ✅
}
}
تحلیل: lock مثل یک گاردروب در اتاق است؛ هر Thread که وارد شد، در رو قفل میکنه و بقیه باید بیرون منتظر بمونن (یا به اصطلاح block میشن).
۵.۴. مثال ۴: راه حل سبکتر — Interlocked
using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static int counter = 0;
static void Main()
{
Parallel.For(0, 1_000_000, i =>
{
Interlocked.Increment(ref counter); // ✅ اتومیک و بسیار سریع
});
Console.WriteLine($"Counter: {counter}"); // 1,000,000
}
}
🎯 برای عملیاتهای ریاضی ساده روی
int،long،doubleو pointer ها،Interlockedبهترین انتخاب است (در حدود ۱۰ تا ۵۰ برابر سریعتر ازlock).
۵.۵. مثال ۵: راه حل مدرن — ConcurrentDictionary
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
class Program
{
static ConcurrentDictionary<int, string> cache = new();
static void Main()
{
Parallel.For(0, 100, i =>
{
// ✅ یک متد با کل عملیات: atomic و thread-safe
cache.GetOrAdd(5, id => $"Data-{id}");
});
Console.WriteLine($"Cache count: {cache.Count}"); // همیشه 1
}
}
۶. مثال واقعی و کاربردی
۶.۱. سناریو: سیستم انتقال وجه بانک
این یک سناریوی Production واقعی است. اگر درست پیاده نشه، پول مشتری ناپدید میشه!
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
public class BankAccount
{
public int AccountId { get; }
public decimal Balance { get; private set; }
private static readonly ConcurrentDictionary<int, BankAccount> _accounts = new();
public BankAccount(int id, decimal initialBalance)
{
AccountId = id;
Balance = initialBalance;
}
public static BankAccount GetOrCreate(int id, decimal initial = 0)
=> _accounts.GetOrAdd(id, i => new BankAccount(i, initial));
}
// ❌ نسخه دارای Race Condition
public class UnsafeTransfer
{
public static bool Transfer(BankAccount from, BankAccount to, decimal amount)
{
if (from.Balance < amount)
return false;
// ⚠️ بین خواندن و نوشتن، Thread دیگهای میتونه Balance رو تغییر بده!
from.Balance -= amount;
to.Balance += amount;
return true;
}
}
// ✅ نسخه امن با lock روی هر دو حساب
public class SafeMoneyTransfer1
{
private static readonly object _globalLock = new object();
public static bool Transfer(BankAccount from, BankAccount to, decimal amount)
{
lock (_globalLock) // ساده ولی کمکارایی
{
if (from.Balance < amount)
return false;
from.Balance -= amount;
to.Balance += amount;
return true;
}
}
}
// ✅ نسخه حرفهای: قفل مرتبسازی (Lock Ordering) برای جلوگیری از Deadlock
public class SafeMoneyTransfer2
{
// نمونه قفل اختصاصی برای هر حساب
private static readonly ConcurrentDictionary<int, object> _accountLocks = new();
private static object GetLock(BankAccount acc)
=> _accountLocks.GetOrAdd(acc.AccountId, _ => new object());
public static bool Transfer(BankAccount from, BankAccount to, decimal amount)
{
// ترتیب قفلها بر اساس ID → جلوگیری از Deadlock
var lock1 = from.AccountId < to.AccountId ? from : to;
var lock2 = from.AccountId < to.AccountId ? to : from;
lock (GetLock(lock1))
{
lock (GetLock(lock2))
{
if (from.Balance < amount)
return false;
from.Balance -= amount;
to.Balance += amount;
return true;
}
}
}
}
class Program
{
static void Main()
{
var alice = BankAccount.GetOrCreate(1, 1000);
var bob = BankAccount.GetOrCreate(2, 1000);
// مدام پول بین دو حساب جابجا میشه (با Race: همه میرن به یک حساب)
Parallel.For(0, 10_000, i =>
{
SafeMoneyTransfer2.Transfer(alice, bob, 10);
SafeMoneyTransfer2.Transfer(bob, alice, 10);
});
Console.WriteLine($"Alice: {alice.Balance}, Bob: {bob.Balance}");
Console.WriteLine($"Sum: {alice.Balance + bob.Balance}"); // باید 2000 باشه
}
}
خروجی نسخه امن:
Alice: 1000, Bob: 1000
Sum: 2000
اگر نسخه ناامن (UnsafeTransfer) رو اجرا کنید، Sum ممکنه هر عددی جز ۲۰۰۰ بشه!
۶.۲. سناریو: Lazy Initialization (Singleton爱吃)
using System;
// ❌ نسخه دارای Race
public class NaiveSingleton
{
private static NaiveSingleton? _instance;
public static NaiveSingleton Instance
{
get
{
if (_instance is null) // CHECK
{
_instance = new NaiveSingleton(); // ACT — ممکنه دو بار اجرا بشه
}
return _instance;
}
}
private NaiveSingleton() { }
}
// ✅ نسخه استاندارد 工 double-check
public class SafeSingleton1
{
private static SafeSingleton1? _instance;
private static readonly object _lock = new object();
public static SafeSingleton1 Instance
{
get
{
if (_instance is null)
{
lock (_lock)
{
if (_instance is null) // بار دوم برای اطمینان
_instance = new SafeSingleton1();
}
}
return _instance;
}
}
private SafeSingleton1() { }
}
// ✅✅ بهترین راه در داتنت مدرن: Lazy<T>
public class SafeSingleton2
{
// Lazy<T> بهصورت پیشفرض thread-safe و بدون lock اضافیست
private static readonly Lazy<SafeSingleton2> _lazy =
new(() => new SafeSingleton2());
public static SafeSingleton2 Instance => _lazy.Value;
private SafeSingleton2() { }
}
💡 درسآموخته: داتنت ابزارهای آماده دارد. قبل از اینکه خودتون قفل بنویسید، بگردید دنبال راه آماده (
Lazy<T>،ConcurrentDictionary،Interlocked).
۷. مباحث پیشرفته
۷.۱. مدل حافظه سیشارپ و Memory Model
سیشارپ یک مدل حافظه داره که تعیین میکنه چه عملیاتی توسط Thread های مختلف "قابل مشاهده" است. دو مفهوم کلیدی:
الف) Caching در CPU
CPU cores هر کدام کش L1/L2 خود را دارند. یک تغییر ممکنه فوراً برای Thread دیگهای که روی هستهی دیگهست قابل مشاهده نباشه.
using System;
using System.Threading;
class Program
{
private static bool _stop = false; // ❌ بدون volatile ممکنه برنامه تموم نشه
static void Main()
{
var t = new Thread(() =>
{
Console.WriteLine("Worker started...");
while (!_stop) { } // ممکنه برای همیشه لوپ بزنه!
Console.WriteLine("Worker stopped.");
});
t.Start();
Thread.Sleep(1000);
_stop = true;
t.Join();
}
}
ب) volatile و Memory Barrier
private static volatile bool _stop = false; // ✅ تغییرات بلافاصله منتشر میشن
| ویژگی | توضیح |
|---|---|
| گارانتی | しか visibility (پابلیک شدن تغییرات)، نه atomicity |
| عدم گارانتی | ترتیب یا انحصار؛ جایگزین lock نیست |
| tev Oct کاربرد | فلگهای stop، cancellation |
⚠️ قانون طلایی:
volatileفقطvisibility رو حل میکنه. برای atomicity و mutual exclusion ازlockیاInterlockedاستفاده کنید.
۷.۲. Deadlock — دوست دیگه Race Condition
وقتی میخوایم Race رو حل کنیم، ممکنه تو دردسری بهنام Deadlock بیفتیم: دو Thread که هرکدام منتظر قفلی هستن که دست دیگریست.
using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
private static readonly object _lockA = new object();
private static readonly object _lockB = new object();
static void Main()
{
var t1 = Task.Run(() =>
{
lock (_lockA)
{
Thread.Sleep(100);
lock (_lockB) // ⛔ در حالی که B دست Thread 2ست
{
Console.WriteLine("T1: acquired both");
}
}
});
var t2 = Task.Run(() =>
{
lock (_lockB)
{
Thread.Sleep(100);
lock (_lockA) // ⛔ در حالی که A دست Thread 1ست
{
Console.WriteLine("T2: acquired both");
}
}
});
// هیچکدوم کامل نمیشن! برنامه هنگ میکنه
Task.WaitAll(t1, t2);
}
}
راه حل: Lock Ordering (قفلها رو همیشه به یک ترتیب بگیر) — مثل مثال بانک در فصل قبل.
۷.۳. Lock Contention و Performance
هر قفلی که اضافه میکنید، یک گلوگاه (bottleneck) ایجاد میکنه:
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static int _counter = 0;
static readonly object _lock = new object();
static long _lockWaitTicks = 0;
static void Main()
{
var sw = Stopwatch.StartNew();
// با هشت Thread فعال، contention شدید میشه
Parallel.For(0, 10_000_000, i =>
{
var before = Stopwatch.GetTimestamp();
lock (_lock) { _counter++; }
Interlocked.Add(ref _lockWaitTicks, Stopwatch.GetTimestamp() - before);
});
sw.Stop();
Console.WriteLine($"Counter: {_counter}");
Console.WriteLine($"Total time: {sw.ElapsedMilliseconds} ms");
Console.WriteLine($"Time spent waiting on lock: " +
$"{TimeSpan.FromTicks(_lockWaitTicks).TotalSeconds:F1} s");
}
}
۷.۴. Lock-Free Programming با Interlocked و CAS
Interlocked از دستورات CAS (Compare-And-Swap) سختافزار استفاده میکنه:
using System;
using System.Threading;
class Program
{
static int _value = 0;
// پیادهسازی CompareExchange به صورت دستی
static int InterlockedAdd(int increment)
{
int initial, computed;
do
{
initial = _value;
computed = initial + increment;
// اگر _value هنوز initial است، computed رو بنویس
}
while (Interlocked.CompareExchange(ref _value, computed, initial) != initial);
return computed;
}
static void Main()
{
InterlockedAdd(5);
Console.WriteLine(_value);
}
}
مزایا Lock-Free:
- بدون block کردن Thread
- بدون deadlock
- بسیار سریع
معایب:
- پیچیدهتر برای نوشتن
- فقط برای عملیات ساده
- ممکنه livelock ایجاد کنه (حلقه بینهایت CAS ناموفق)
۷.۵. Immutable State — ریشهکن کردن Race
بهترین قفل، عدم وجود داده مشترک است! ساختارهای Immutable رو قابل اشتراک امن میکنه:
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Threading.Tasks;
// ✅ Record کاملاً Immutable
public record ServerConfig(string Version, ImmutableDictionary<string, string> Settings);
public class ConfigurationManager
{
// جایگزین با atomic swap; بدون نیاز به lock برای خوانندگان
private ImmutableDictionary<string, string> _settings =
ImmutableDictionary<string, string>.Empty;
public void Set(string key, string value)
{
// WithModifiers مستلزم کپی، ولی atomic میشه با Interlocked.Exchange
ImmutableDictionary<string, string> original, updated;
do
{
original = _settings;
updated = original.SetItem(key, value);
}
while (Interlocked.CompareExchange(ref _settings, updated, original) != original);
}
public string? Get(string key) => _settings.TryGetValue(key, out var v) ? v : null;
public ImmutableDictionary<string, string> GetAll() => _settings; // snapshot امن
}
class Program
{
static void Main()
{
var mgr = new ConfigurationManager();
Parallel.For(0, 1000, i => mgr.Set($"k{i}", i.ToString()));
Console.WriteLine($"Total keys: {mgr.GetAll().Count}"); // همیشه 1000
}
}
💡 این الگو به Copy-on-Write معروف است و در سیستمهای enterprise بهشدت استفاده میشه.
۷.۶. System.Threading.Channels — جایگزین modern
به جای اشتراک داده مستقیم، Thread ها رو ازطریق کانال با هم حرف بزنید:
using System;
using System.Threading.Channels;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
// ظرفیت نامحدود: تولیدکننده و مصرفکننده بدون اشتراک مستقیم
var channel = Channel.CreateUnbounded<int>();
// تولیدکننده
var producer = Task.Run(async () =>
{
for (int i = 0; i < 100; i++)
await channel.Writer.WriteAsync(i);
channel.Writer.Complete();
});
// مصرفکننده (میتونه چندتا باشه)
var consumers = new List<Task>();
for (int c = 0; c < 4; c++)
{
consumers.Add(Task.Run(async () =>
{
await foreach (var item in channel.Reader.ReadAllAsync())
{
Console.WriteLine($"[{Environment.CurrentManagedThreadId}] got {item}");
}
}));
}
await producer;
await Task.WhenAll(consumers);
}
}
🎯 Channels کاملترین راه مدرن داتنت برای هماهنگی Thread هاست (اتمیک پردازش میشه و نیاز به lock رو کم میکنه).
۸. اشتباهات رایج
۸.۱. قفل this یا string یا typeof(...)
// ❌ بد: قفل روی this — کد بیرون هم میتونه روی شی شما قفل بگیره → deadlock
public void DoWork()
{
lock (this) { /* ... */ }
}
// ❌ بد: قفل روی string — string ها Intern میشن و مشترک هستن
lock ("myLock") { /* ... */ }
// ❌ بد: قفل روی type — اپلیکیشن کلاس رو share میکنه
lock (typeof(MyClass)) { /* ... */ }
// ✅ خوب: object خصوصی readonly
private static readonly object _lock = new object();
lock (_lock) { /* ... */ }
۸.۲. قراردادن false-confidence روی Concurrent Collections
using System.Collections.Concurrent;
using System.Linq;
var dict = new ConcurrentDictionary<int, int>();
// ❌ ContainsKey و TryAdd دو عمل جداگانهاند → همچنان Race هست!
if (!dict.ContainsKey(42))
dict.TryAdd(42, 0);
// ✅ از متدهای atomic استفاده کنید
dict.TryAdd(42, 0); // یا:
dict.AddOrUpdate(42, 0, (k, v) => v + 1);
dict.GetOrAdd(42, k => LoadValue(k));
۸.۳. فراخوانی کد بیرون داخل lock
private readonly object _lock = new object();
public event EventHandler? SomethingHappened;
// ❌ فاجعه: میتونه deadlock بشه چون handler ممکنه قفل دیگهای بخواد
public void Process()
{
lock (_lock)
{
SomethingHappened?.Invoke(this, EventArgs.Empty); // ⛔
}
}
// ✅ snapshot از delegate بیرون از lock بگیر
public void Process()
{
EventHandler? handler;
lock (_lock)
{
// state رو آماده کن
}
handler = SomethingHappened; // کپی atomic
handler?.Invoke(this, EventArgs.Empty); // بیرون از lock
}
۸.۴. استفاده از lock در async متدها
// ❌ کد کامپایل نمیشه
public async Task DoAsync()
{
lock (_lock)
{
await Task.Delay(100); // CS1996
}
}
// ✅ از SemaphoreSlim در async استفاده کنید
private static readonly SemaphoreSlim _sem = new(1, 1);
public async Task DoAsync()
{
await _sem.WaitAsync();
try
{
await Task.Delay(100);
}
finally
{
_sem.Release();
}
}
۸.۵. فکر کردن async/await بهتنهایی thread-safe است
private static int _votes = 0;
// ❌ همچنان race وجود داره چون await ادامه روی thread دیگهست
public static async Task VoteAsync()
{
await Task.Delay(10);
_votes++; // ⛔ دو await میتونن مشترکاً این رو اجرا کنن
}
// ✅
public static async Task VoteAsync()
{
await Task.Delay(10);
Interlocked.Increment(ref _votes);
}
۸.۶. هول ندادن lock داخل حلقه
// ⚠️ کارایی پایین: lock و unlock در هر iteration
for (int i = 0; i < 1000; i++)
{
lock (_lock) { _sum += Compute(i); }
}
// ✅ بهتر: lock یکبار در سطح batch
lock (_lock)
{
for (int i = 0; i < 1000; i++)
_sum += Compute(i);
}
(البته اگه Compute سریع نباشه، نگهداشتن طولانی قفل هم بد است — خواندن فصل ۱۴.)
۹. بهترین روشها (Best Practices)
۹.۱. سلسلهمراتب راه حلها (اولین آپشن رو انتخاب کنید)
| اولویت | راه | وقتی استفاده میشه |
|---|---|---|
| ۱ | Concurrent collections | ConcurrentDictionary, ConcurrentQueue, ConcurrentBag |
| ۲ | Interlocked | شمارنده، swap، CAS روی مقادیر ساده |
| ۳ | atomic snapshot با Immutable | state تنظیمات، config، snapshot |
| ۴ | Lazy |
مقداردهی تنبل |
| ۵ | lock | بقیه موارد، دسترسیهای مرکب |
| ۶ | ReaderWriterLockSlim | خوانندگان زیاد، نویسنده کم |
| ۷ | Mutex | هماهنگی بین پردازشها |
| ۸ | Channels | producer/consumer pipeline |
۹.۲. قانون قفل (Locking Rules)
۱. همیشه از یک object خصوصی readonly استفاده کن.
۲. همیشه lock رو در try/finally بذار (یا از lock statement پشتیبانی بگیر که خودش این کارو میکنه).
۳.Neverکد بیرون (event invoke، virtual method، I/O) داخل lock اجرا نکن.
۴. قفلها رو به یک ترتیب ثابت بگیر تا deadlock نشن.
۵. مدت نگهداشتن قفل رو کوتاه نگهدار.
۹.۳. Design Patterns کاربردی
الف) الگوی Snapshot
public class Configuration
{
private ImmutableDictionary<string, string> _state =
ImmutableDictionary<string, string>.Empty;
public ImmutableDictionary<string, string> Current => _state; // snapshot امن
}
ب) الگوی Actor / Message-passing
بهجای اشتراک state، یک Thread مسئول state و بقیه بهش پیام میدن:
using System.Collections.Concurrent;
public sealed class WorkerActor : IDisposable
{
private readonly BlockingCollection<string> _inbox = new();
private readonly Thread _thread;
public WorkerActor()
{
_thread = new Thread(Run) { IsBackground = true };
_thread.Start();
}
public void Tell(string message) => _inbox.Add(message);
private void Run()
{
foreach (var msg in _inbox.GetConsumingEnumerable())
{
Process(msg); // فقط این Thread به state دسترسی داره
}
}
private void Process(string msg) { /* ... */ }
public void Dispose() => _inbox.CompleteAdding();
}
۹.۴. تست Race Condition
using System.Threading.Tasks;
using Xunit;
public class CounterTests
{
[Fact]
public void Counter_ShouldBeThreadSafe()
{
//Arrange: تست رو چند بار تکرار کن چون race غیرقطعی است
for (int attempt = 0; attempt < 20; attempt++)
{
int counter = 0;
const int threadCount = 8;
const int perThread = 50_000;
Parallel.For(0, threadCount, _ =>
{
for (int i = 0; i < perThread; i++)
Interlocked.Increment(ref counter);
});
Assert.Equal(threadCount * perThread, counter);
}
}
}
۹.۵. استفاده از ابزارها
| ابزار | نوع | کاربرد |
|---|---|---|
| Visual Studio Concurrency Visualizer | دیباگ | تحلیل timeline قفلها |
| dotnet-counters | CLI | مانیتورING contention و lock |
| JetBrains dotTrace | پروفایلر | پیدا کردن hot lock |
| Coyote / Accuracy | تست | شبیهسازی زمانبندیهای مختلف |
۱۰. منابع و ادامه مسیر
۱۰.۱. لینکهای رسمی مایکروسافت
- Thread Synchronization (Microsoft Learn)
- Interlocked Class (API Reference)
- ConcurrentDictionary<TKey,TValue>
- Channels
۱۰.۲. کتابها (به شدت توصیه میشه)
| کتاب | نویسنده | سطح |
|---|---|---|
| Concurrency in C# Cookbook | Stephen Cleary | متوسط–پیشرفته |
| Pro .NET Memory Management | Konrad Kokosa | پیشرفته |
| Programming C# 12 (فصل Thread) | Ian Griffiths | متوسط |
| C# in Depth (فصل Async) | Jon Skeet | پیشرفته |
۱۰.۳. مسیر یادگیری پیشنهادی
[۱] Thread/Task basics (۱ هفته)
↓
[۲] Race Condition + Interlocked (این آموزش!)
↓
[۳] lock و deadlocks (۱ هفته)
↓
[۴] Concurrent collections (۱ هفته)
↓
[۵] TPL Dataflow وChannels (۲ هفته)
↓
[۶] Reactivity / Actor Model (۱ ماه)
↓
[۷] memory models, lock-free (پیشرفته)
۱۰.۴. تمرینهای خودتون رو انجام بدید
- یک
ConcurrentDictionary-based cache بسازید که از دیتابیس بخونه. - یک rate-limiter پیادهسازی کنید که از
Interlockedاستفاده کنه. - یک producer-consumer با
Channelبسازید که بتواند 1M پیام در ثانیه پردازش کنه. - در GitHub پروژههای متنباز، کلمه "lock" رو سرچ کنید و reason قفلها رو تحلیل کنید.
۱۱. مرجع کامل توابع و متدها (API Deep Dive)
در این فصل، مهمترین APIهای هماهنگی رو عمیق تحلیل میکنیم.
۱۱.۱. Interlocked — ابزار اتومیک سبک
امضا (کلاس):
public static class Interlocked
متدهای اصلی:
| متد | امضا | توضیح |
|---|---|---|
Increment |
int Increment(ref int location) |
یکی اضافه کن |
Decrement |
int Decrement(ref int location) |
یکی کم کن |
Add |
int Add(ref int location, int value) |
مقدار اضافه کن |
Exchange |
T Exchange<T>(ref T location, T value) |
مقدار جدید رو بذار، قدیمی رو برگردون |
CompareExchange |
T CompareExchange<T>(ref T location, T value, T comparand) |
اگر مقدار فعلی == comparand بود، value رو بذار |
Read |
long Read(ref long location) |
خواندن اتومیک long روی ۳۲-بیت |
خروجی (Return): مقدار جدید ذخیره شده (در Exchange مقدار قدیمی).
گام به گام CompareExchange:
- مقدار
locationرو بهصورت اتومیک میخونه. - اگر با
comparandبرابر بود،valueرو توش مینویسه. - در هر دو حالت، مقدار قدیمی رو برمیگردونه (نه جدید).
مثال ۱: شمارنده امن
int counter = 0;
Parallel.For(0, 1000, i => Interlocked.Increment(ref counter));
مثال ۲: MAX اتومیک (CAS loop)
static int _max = 0;
static void UpdateMax(int candidate)
{
int initial, computed;
do
{
initial = _max;
computed = Math.Max(initial, candidate);
}
while (Interlocked.CompareExchange(ref _max, computed, initial) != initial);
}
// Parallel.For(0, 1000, i => UpdateMax(Random.Shared.Next()));
مثال ۳: lazy initialization بدون lock
private static object? _resource;
public static object Resource =>
LazyInitializer.EnsureInitialized(ref _resource, () => new object());
Exceptions:
| Exception | موقع رخ دادن |
|---|---|
NullReferenceException |
location اشارهگر null |
InvalidOperationException |
泛 type پشتیبانی نشده (در Overload 的 generic قدیمی) |
Overloadها: برای int، long، ulong، float، double، object, Tgeneric، IntPtr موجود است.
اشتباه رایج: فکر کردن Interlocked هم visibility رو هم ترتیب رو گارانتی میکنه. این فقط atomicity اون عمل خاص رو میده.
متدهای مرتبط: Volatile.Read، Volatile.Write, LazyInitializer.
۱۱.۲. lock / Monitor — قفل استاندارد
امضا:
// Statement (شکر syntactic روی Monitor)
lock (object obj) { /* ... */ }
// کلاس پایهای
public static class Monitor
{
public static void Enter(object obj);
public static void Exit(object obj);
public static bool TryEnter(object obj, int millisecondsTimeout);
public static void Pulse(object obj);
public static void Wait(object obj);
}
پارامترها:
| پارامتر | نوع | توضیح |
|---|---|---|
obj |
object |
شیء که به عنوان قفل استفاده میشه (نه null) |
خروجی: TryEnter یک bool برمیگردونه؛ بقیه void.
گام به گام lock:
1.CLR یک sync block برای شیء ایجاد میکنه (لینک به header شیء).
2. Thread سعی میکنه قفل رو بگیره؛ اگر آزاد بود، وارد میشه.
3. اگر مشغول بود، Thread در حالت blocked قرار میگیره (هیچ CPU مصرف نمیکنه).
4. وقتی صاحب قفل از lock خارج شد، CLR یک Thread منتظر رو بیدار میکنه.
5. در finally، Exit فراخوانی میشه (lock واقعاً این رو تضمین میکنه).
مثال ۱: dictionary امن
private static readonly Dictionary<string, int> _counts = new();
private static readonly object _lock = new();
public static void AddOne(string key)
{
lock (_lock)
{
if (!_counts.TryGetValue(key, out var v))
_counts[key] = 1;
else
_counts[key] = v + 1;
}
}
مثال ۲: timeout برای جلوگیری از deadlock
if (Monitor.TryEnter(_lock, TimeSpan.FromSeconds(5)))
{
try
{
// کار حساس
}
finally
{
Monitor.Exit(_lock);
}
}
else
{
throw new TimeoutException("Lock not acquired within 5 seconds");
}
Exceptions:
| Exception | موقع رخ دادن |
|---|---|
ArgumentNullException |
obj null |
SynchronizationLockException |
Exit بدون Enter |
اشتباهات رایج:
- استفاده از
Monitor.Enterدستی بدونtry/finally(گرفتار deadlock اگه exception پرت بشه) - استفاده از ساختار
structبه عنوان قفل (boxing → قفل اشتباه) - قفل اشیاء
stringبه دلیل interning
متدهای مرتبط: Pulse/Wait برای producer-consumer سنتی (امروزه از BlockingCollection استفاده میشه).
۱۱.۳. SemaphoreSlim — قفل قابل async
امضا:
public sealed class SemaphoreSlim : IDisposable
{
public SemaphoreSlim(int initialCount);
public SemaphoreSlim(int initialCount, int maxCount);
public int CurrentCount { get; }
public void Wait();
public bool Wait(int millisecondsTimeout);
public Task WaitAsync();
public Task<bool> WaitAsync(int millisecondsTimeout);
public int Release();
public int Release(int releaseCount);
}
پارامترها:
| پارامتر | نوع | توضیح |
|---|---|---|
initialCount |
int |
تعداد "پرمیت" موجود در ابتدا |
maxCount |
int |
حداکثر permیت |
millisecondsTimeout |
int |
timeout |
خروجی: Release تعداد perm قبل از release رو برمیگردونه.
گام به گام:
- Semaphore یک counting lock است (چند Thread میتونن همزمان وارد بشن).
Waitیک perm میگیره (اگه موجود نباشه صبر میکنه).Releaseیک perm رو برمیگردونه (هر Thread که تموم شد باید Release بزنه).- وقتی
initialCount = 1باشه، معادل یک mutex/lock میشه (اما cross-process نیست).
مثال ۱: بستن تعداد فراخوانیهای همزمان API
private static readonly SemaphoreSlim _apiLimiter = new(3, 3); // max 3 concurrent
public static async Task<string> CallApiAsync()
{
await _apiLimiter.WaitAsync();
try
{
using var client = new HttpClient();
return await client.GetStringAsync("https://example.com/data");
}
finally
{
_apiLimiter.Release();
}
}
مثال ۲: به عنوان async lock
private static readonly SemaphoreSlim _fileLock = new(1, 1);
public static async Task AppendAsync(string path, string text)
{
await _fileLock.WaitAsync();
try
{
await File.AppendAllTextAsync(path, text);
}
finally
{
_fileLock.Release();
}
}
Exceptions:
| Exception | موقع رخ دادن |
|---|---|
ArgumentOutOfRangeException |
initialCount/maxCount نامعتبر |
ObjectDisposedException |
semaphore disposed شده |
SemaphoreFullException |
Release بیش از perm vhد |
اشتباهات:
- فراموش کردن
Releaseدرfinally - استفاده از
Mutexدر async (این cross-process ولی km کارایی)
۱۱.۴. ReaderWriterLockSlim — خوانندگان زیاد، نویسنده کم
امضا:
public class ReaderWriterLockSlim : IDisposable
{
public void EnterReadLock();
public void ExitReadLock();
public void EnterWriteLock();
public void ExitWriteLock();
public void EnterUpgradeableReadLock();
public void ExitUpgradeableReadLock();
}
مثال ۱: cache امن
public class ThreadSafeCache<TKey, TValue> where TKey : notnull
{
private readonly Dictionary<TKey, TValue> _inner = new();
private readonly ReaderWriterLockSlim _rw = new();
public TValue GetOrAdd(TKey key, Func<TKey, TValue> factory)
{
// ۱) خواندن: چند Thread همزمان مجاز
_rw.EnterReadLock();
try
{
if (_inner.TryGetValue(key, out var value))
return value;
}
finally { _rw.ExitReadLock(); }
// ۲) writing: انحصاری
_rw.EnterWriteLock();
try
{
if (_inner.TryGetValue(key, out var value))
return value; // دوباره چ کن (شاید Thread دیگه اضافه کرده)
var newValue = factory(key);
_inner[key] = newValue;
return newValue;
}
finally { _rw.ExitWriteLock(); }
}
}
مثال ۲: upgradeable read
_rw.EnterUpgradeableReadLock();
try
{
if (NeedToWrite())
{
_rw.EnterWriteLock();
try { /* write */ }
finally { _rw.ExitWriteLock(); }
}
}
finally { _rw.ExitUpgradeableReadLock(); }
⚠️ این دارای recursive policy است و ممکنه deadlock ایجاد کنه. در داتنت مدرن، کلاس های مثل
ConcurrentDictionaryمعمولاً بهتر هستند.
۱۱.۵. ConcurrentDictionary<TKey, TValue> — دیکشنری امن
متدهای atomic کلیدی:
| متد | کاربرد |
|---|---|
GetOrAdd(key, factory) |
اگر موجود نبود، با factory بساز |
AddOrUpdate(key, addValue, updateFactory) |
اضافه یا آپدیت |
TryAdd, TryRemove, TryUpdate |
عملیات شرطی |
GetOrAdd(key, value) |
اضافه اگر نبود |
💡 نکته پیشرفته: ممکن است factory در
GetOrAddبیش از یک بار اجرا بشه (بهصورت موازی)، ولی فقط یک مقدار افزوده میشه. پس factory باید side-effect عاری باشه:
// ⚠️ ممکنه چند بار اجرا بشه!
var value = dict.GetOrAdd(5, key => ExpensiveDatabaseCall(key));
// ✅ اگر نیاز هست فقط یک بار اجرا بشه، مقدار رو از قبل بساز
var v = new Obj();
dict.GetOrAdd(5, v); // Overload با value، factory اجرا نمیشه
۱۱.۶. Volatile و Memory Barriers
public static class Volatile
{
public static void Write(ref int location, int value);
public static int Read(ref int location);
}
تفاوت با volatile کلمه کلیدی: Volatile.* روی field های معمولی هم قابل استفاده است.
private int _flag = 0;
// ✅ write دارای release fence
Volatile.Write(ref _flag, 1);
// ✅ read دارای acquire fence
if (Volatile.Read(ref _flag) == 1) { /* ... */ }
۱۱.۷. Mutex — قفل بین پروسهای
using var mutex = new Mutex(false, "Global\\MyApp_SingleInstance");
try
{
if (!mutex.WaitOne(TimeSpan.FromSeconds(2)))
{
Console.WriteLine("Another instance is running");
return;
}
// اجرای تکنمونهی اپلیکیشن
}
finally
{
mutex.ReleaseMutex();
}
| ویژگی | توضیح |
|---|---|
| Cross-process | بله، با نام در OS ثبت میشه |
| هزینهاش | زیاد (syscall)، خیلی کندتر از lock |
| کاربرد | single-instance apps، سینک بین پردازشها |
⚠️
Mutexاز یک Thread به Thread دیگه در همون process هم میتونه پاس داده بشه، ولیlockنه.
۱۱.۸. Lazy<T> — مقداردهی امن
public class Lazy<T>
{
public Lazy();
public Lazy(bool isThreadSafe); // false → بدون overhead
public Lazy(Func<T> valueFactory);
public Lazy(LazyThreadSafetyMode mode);
public bool IsValueCreated { get; }
public T Value { get; }
}
| حالت | رفتار |
|---|---|
ExecutionAndPublication (پیشفرض) |
lock کامل; factory دقیقاً یکبار اجرا |
PublicationOnly |
factory ممکنه چندبار اجرا، اولین برنده |
None |
نه thread-safe |
// ✅ پیشفرض: thread-safe
private static readonly Lazy<BigObject> _big =
new(() => new BigObject());
public static BigObject Big => _big.Value;
۱۲. مقایسه کلاسها و توابع مشابه
۱۲.۱. جدول مقایسهای مکانیزمهای هماهنگی
| مکانیزم | کارایی | Async-friendly | Cross-process | دامنه | پیچیدگی |
|---|---|---|---|---|---|
Interlocked |
★★★★★ | ✅ (بدون await) | ❌ | اعداد ساده | پایین |
lock (Monitor) |
★★★ | ❌ | ❌ | ساختاری، کوتاه | پایین |
SemaphoreSlim |
★★★★ | ✅ | ❌ | async workloads | پایین |
Mutex |
★ | ❌ | ✅ | cross-process singularity | متوسط |
ReaderWriterLockSlim |
★★★ | ❌ | ❌ | read-heavy | متوسط |
ConcurrentDictionary |
★★★★★ | ✅ (با configure await) | ❌ | dictionary | پایین |
Channels |
★★★★★ | ✅ | ❌ | pipelines | متوسط |
volatile |
★★★ | ن/a | ❌ | flags | پایین |
۱۲.۲. lock در برابر Monitor دربرابر Mutex
// ۱) lock — ساده و پیشفرض
lock (_obj) { DoWork(); }
// ۲) Monitor — معادل دستی lock با قابلیت timeout
Monitor.Enter(_obj, ref lockTaken);
try { DoWork(); }
finally { if (lockTaken) Monitor.Exit(_obj); }
// ۳) Mutex — بین پردازشها (کند)
using var m = new Mutex(true, "Global\\name");
m.WaitOne();
try { DoWork(); } finally { m.ReleaseMutex(); }
۱۲.۳. ConcurrentDictionary در برابر lock + Dictionary
| سناریو | چه چیزی بهتر است |
|---|---|
| فقط Get/Add ساده | ConcurrentDictionary |
| operation مرکب روی multiple keys | lock روی Dictionary |
| خواندن بسیار زیاد تخمین زده | ConcurrentDictionary (lock-free reads) |
| نیاز به atomic iteration | ImmutableDictionary |
۱۳. سناریوهای واقعی
در این فصل، پنج سناریوی واقعی تولید رو بررسی میکنیم.
۱۳.۱. سناریو: Rate Limiter توزیعشده
using System;
using System.Threading;
public class TokenBucketRateLimiter : IDisposable
{
private readonly int _capacity;
private readonly double _refillTokensPerSecond;
private double _tokens;
private long _lastRefillTicks;
private readonly Timer _refillTimer;
public TokenBucketRateLimiter(int capacity, double refillPerSecond)
{
_capacity = capacity;
_refillTokensPerSecond = refillPerSecond;
_tokens = capacity;
_lastRefillTicks = DateTime.UtcNow.Ticks;
// refill در پسزمینه
_refillTimer = new Timer(_ => Refill(), null, 100, 100);
}
private void Refill()
{
var now = DateTime.UtcNow.Ticks;
var elapsedSeconds = (now - Interlocked.Exchange(ref _lastRefillTicks, now)) / (double)TimeSpan.TicksPerSecond;
Interlocked.Exchange(ref _tokens, Math.Min(_capacity, _tokens + elapsedSeconds * _refillTokensPerSecond));
}
// ✅ ورژن واقعی با double atomic via Interlocked.Exchange
public bool TryAcquire(int tokens = 1)
{
double current, computed;
do
{
current = _tokens;
computed = current - tokens;
if (computed < 0)
return false;
}
while (Interlocked.CompareExchange(ref _tokens, computed, current) != current);
return true;
}
public void Dispose() => _refillTimer.Dispose();
}
استفاده:
var limiter = new TokenBucketRateLimiter(capacity: 10, refillPerSecond: 5);
Parallel.For(0, 100, i =>
{
if (limiter.TryAcquire())
Console.WriteLine($"Request {i} allowed");
else
Console.WriteLine($"Request {i} rejected");
});
۱۳.۲. سناریو: Cache با Expiry
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
public class ThreadSafeCache<TKey, TValue> where TKey : notnull
{
private readonly ConcurrentDictionary<TKey, CacheEntry> _entries = new();
private readonly Func<TKey, Task<TValue>> _loader;
private readonly TimeSpan _ttl;
private record CacheEntry(TValue Value, long ExpiresAtTicks);
public ThreadSafeCache(Func<TKey, Task<TValue>> loader, TimeSpan ttl)
{
_loader = loader;
_ttl = ttl;
}
public async Task<TValue> GetAsync(TKey key)
{
// مسیر سریع: hit
if (_entries.TryGetValue(key, out var entry) &&
entry.ExpiresAtTicks > DateTime.UtcNow.Ticks)
{
return entry.Value;
}
// مسیر کند: load + store (atomic)
var value = await _loader(key);
var newEntry = new CacheEntry(value, DateTime.UtcNow.Add(_ttl).Ticks);
_entries[key] = newEntry; // ConcurrentDictionary.AddOrUpdate بینیاز
return value;
}
public void Invalidate(TKey key) => _entries.TryRemove(key, out _);
}
🎯 نکته: در این الگو چند Thread ممکنه همزمانبارگذاری بشن (cache stampede). در production از
Lazy<Task<TValue>>یا Semaphore-per-key استفاده میشه (بهعنوان تمرین!).
۱۳.۳. سناریو: Processing Pipeline با Channels
using System;
using System.Threading.Channels;
using System.Threading.Tasks;
public class ImageProcessingPipeline
{
public async Task RunAsync(int imageCount)
{
var download = Channel.CreateBounded<string>(100);
var resize = Channel.CreateBounded<string>(50);
// مرحله ۱: دانلود
var downloader = Task.Run(async () =>
{
for (int i = 0; i < imageCount; i++)
{
await download.Writer.WriteAsync($"image-{i}.png");
}
download.Writer.Complete();
});
// مرحله ۲: تغییر اندازه (۳ consumer)
var resizers = new List<Task>();
for (int i = 0; i < 3; i++)
{
resizers.Add(Task.Run(async () =>
{
await foreach (var path in download.Reader.ReadAllAsync())
{
var resized = Resize(path);
await resize.Writer.WriteAsync(resized);
}
}));
}
// مرحله ۳: آپلود
var uploader = Task.Run(async () =>
{
await foreach (var path in resize.Reader.ReadAllAsync())
{
Upload(path);
}
});
await downloader;
await Task.WhenAll(resizers);
resize.Writer.Complete();
await uploader;
}
private string Resize(string p) => p.Replace(".png", "_small.png");
private void Upload(string p) => Console.WriteLine($"Uploaded {p}");
}
چرا این الگو Race رو کم میکنه؟ هر مرحله state خودش رو داره و ارتباط فقط از طریق channel هست —نه اشتراک مستقیم.
۱۳.۴. سناریو: Counter Event (progress reporting)
using System;
using System.Threading;
using System.Threading.Tasks;
public class ParallelJobRunner
{
private int _completed = 0;
private int _total = 0;
private int _failed = 0;
public void Run(IEnumerable<Action> jobs, int degreeOfParallelism = 4)
{
var jobList = jobs.ToList();
Interlocked.Exchange(ref _total, jobList.Count);
var options = new ParallelOptions { MaxDegreeOfParallelism = degreeOfParallelism };
Parallel.ForEach(jobList, options, job =>
{
try
{
job();
Interlocked.Increment(ref _completed);
}
catch
{
Interlocked.Increment(ref _failed);
}
});
Console.WriteLine($"Done: {_completed} succeeded, {_failed} failed, {_total} total");
}
}
۱۳.۵. سناریو: IoC Singleton با state
public class SessionManager
{
// ✅ snapshot immutable — خوانندگان همزمان بدون lock
private ImmutableDictionary<string, Session> _sessions =
ImmutableDictionary<string, Session>.Empty;
public void AddSession(Session session)
{
// CAS loop برای update atomic
ImmutableDictionary<string, Session> original, updated;
do
{
original = _sessions;
updated = original.Add(session.Id, session);
}
while (Interlocked.CompareExchange(ref _sessions, updated, original) != original);
}
public void RemoveSession(string id)
{
ImmutableDictionary<string, Session> original, updated;
do
{
original = _sessions;
updated = original.Remove(id);
}
while (Interlocked.CompareExchange(ref _sessions, updated, original) != original);
}
public Session? Get(string id)
{
var snapshot = _sessions; // خواندن atomic
return snapshot.TryGetValue(id, out var s) ? s : null;
}
}
۱۴. کارایی و Performance
۱۴.۱. اعداد واقعی (Benchmark فرضی روی یک دستگاه ۸ هستهای)
| عمل | زمان نسبی | ذخیره |
|---|---|---|
int x++ (بدون قفل) |
1x | — |
Interlocked.Increment |
~20x | ۱ |
lock بدون contention |
~50x | ۲ |
lock با ۸ Thread (contended) |
~500x | ۱۰ |
ConcurrentDictionary.GetOrAdd |
~30x | — |
Mutex |
~1000x | — |
💡 درس: Overhead قفل ثابت نیست. وقتی contended بشه، افت کارایی بهصورت نمایی افزایش پیدا میکنه.
۱۴.۲. استراتژیهای بهینهسازی
استراتژی ۱: کاهش بخش بحرانی (Critical Section)
// ❌ کار زیاد داخل lock
lock (_lock)
{
var data = DownloadFromWeb(); // ⛔ I/O داخل lock
Process(data);
}
// ✅ I/O بیرون از lock، فقط نتیجه atomic save شو
var data = await DownloadFromWeb();
lock (_lock) { _lastData = data; }
استراتژی ۲: Sharding (قفلهای جداگانه)
// بهجای یک قفل سراسری، N قفل بر اساس bucket
public class ShardedCounter
{
private const int Shards = 16;
private readonly int[] _counts = new int[Shards];
public void Increment(int key)
{
var slot = key & (Shards - 1);
Interlocked.Increment(ref _counts[slot]);
}
public int Total
{
get
{
int sum = 0;
for (int i = 0; i < Shards; i++)
sum += Interlocked.Add(ref _counts[i], 0); // atomic read
return sum;
}
}
}
استراتژی ۳: Lock-Free با immutable snapshots
(در فصل ۱۳.۵ بررسی شد.)
استراتژی ۴: batching
// بهجای increment هر آیتم، درآخر به صورت batch اعمال کن
int localCount = 0;
foreach (var item in items)
{
if (Matches(item)) localCount++;
}
Interlocked.Add(ref _globalCount, localCount); // یکبار
۱۴.۳. تشخیص قفلهای داغ (Hot Locks)
از dotnet-counters استفاده کنید:
dotnet tool install -g dotnet-counters
dotnet-counters monitor --process-id <PID> \
--counters System.Runtime[contention-rate,monitor-lock-contention-rate]
و یا در Visual Studio: Debug > Performance Profiler > Concurrency Visualizer.
۱۵. چکلیست یادگیری
برای اطمینان از تسلط کامل، این ۲۰ مورد رو تیک بزنید:
مفاهیم پایه (۷ مورد)
- ۱. تعریف Race Condition رو از حفظ بیان کن (۳ شرط لازم).
- ۲. توضیح بده چرا
i++غیراتمیک است (READ/ADD/WRITE). - ۳. فرق Process و Thread رو بدونی.
- ۴. بگی چرا دو Thread فقط خواننده race ندارن.
- ۵. Data Race رو از Logical Race تشخیص بدی.
- ۶. بدونی چرا Race Condition در تستهای تکنخی پیدا نمیشه.
- ۷. مفهوم Thread-Safety رو تعریف کنی.
راهحلها (۷ مورد)
- ۸. یک مثال از باگ counter و از
Interlockedبنویسی. - ۹. یک Toctou باگ بنویسی (
if (!Contains) Add) و برطرف کنی. - ۱۰.
lockرو با object خصوصی درست استفاده کنی. - ۱۱.
SemaphoreSlimدر یک متد async استفاده کنی. - ۱۲.
ConcurrentDictionary.GetOrAddرو ازContainsKey+Addتشخیص بدی. - ۱۳. یک singleton امن با
Lazy<T>بسازی. - ۱۴.
ImmutableArrayیاImmutableDictionaryرو در یک snapshot استفاده کنی.
پیشرفته (۶ مورد)
- ۱۵. یک Deadlock بسازی و با lock ordering درستش کنی.
- ۱۶. یک CAS loop با
Interlocked.CompareExchangeبنویسی. - ۱۷. پیادهسازی ShardedCounter (فصل ۱۴) رو انجام بدی.
- ۱۸. یک pipeline با
Channelبسازی. - ۱۹. یک تست xUnit موازی بنویسی که race رو آشکار کنه.
- ۲۰. توضیح بدی چرا
volatileجایگزینlockنیست.
سخن آخر
Race Condition شاید بترسونه، اما ابزارهای داتنت خیلی کامل هستند. قانون نهایی رو بهیاد بسپار:
داده مشترک رو کم کن → هرچه کمتر اشتراک، کمتر Race.
اگه اشتراک لازمه، atomic API رو انتخاب کن (Interlocked،Concurrent*).
اگه منطق مرکب داره، ازlockبا control کامل استفاده کن.
در نهایت—is LOAD رو با تستهای موازی و φορش verify کن.
موفق باشید! 🚀
Margins:
- اگر عمیقتر شدن lock-free و TPL Dataflow براتون جذاب بود، کتاب Concurrency in C# Cookbook رو حتماً بخونید.
- Repository حاوی تمام مثالهای این آموزش در فصل بعدی قرار داده میشه.