آموزش کامل race condition در سی شارپ و راه حل هاش — از صفر تا حرفه‌ای | + تحلیل متدها و پارامترها

race condition در سی شارپ چیه و راه حل هاش همه سطوح
parsakarimidev.ir

آموزش کامل race condition در سی شارپ و راه حل هاش — از صفر تا حرفه‌ای | + تحلیل متدها و پارامترها

race condition در سی شارپ چیه و راه حل هاشمفهوم سطح: همه سطوح 1405/08/06

آموزش کامل 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 رو تضمین می‌کنه.

۳ اشتباه رایج:

  1. قفل کردن یک Object از نوع string یا Type یا this (Deadlock و کارایی پایین).
  2. استفاده از lock روی کل Dictionary و گمان کردن که این کافیه (دسترسی‌های مرکب atomic نمی‌شن).
  3. صدا زدن کد ناشناس در داخل lock (например calling virtual method or event invocation → Deadlock).

اگر فقط ۵ دقیقه وقت داری:

  1. بدان Race Condition یعنی "اشتراک داده + تغییر هم‌زمان + عدم هماهنگی".
  2. برای شمارنده‌ها از Interlocked.Increment استفاده کن.
  3. برای ساختارهای داده از ConcurrentDictionary یا lock روی یک object خصوصی استفاده کن.
  4. هرگز داخل lock کدی که Call به بیرون می‌زنه ننویس.
  5. کدت رو با تست‌های موازی و کنترل نشده شرط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 (پیشنهاد برای ویندوز)

  1. Visual Studio Community رو رایگان دانلود کنید.
  2. در زمان نصب، workload .NET desktop development یا ASP.NET رو انتخاب کنید.

گزینه ۲: VS Code (سبک و کراس‌پلتفرم)

  1. VS Code رو نصب کنید.
  2. افزونه 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 است:

  1. اشتراک داده (Sharing): دو یا چند Thread به یک منبع مشترک دسترسی دارند.
  2. تغییر (Mutation): حداقل یکی از Thread ها آن را تغییر می‌دهد (نه فقط خواندن).
  3. عدم هماهنگی (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 / LazyInitializer مقداردهی تنبل
۵ 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 تست شبیه‌سازی زمان‌بندی‌های مختلف

۱۰. منابع و ادامه مسیر

۱۰.۱. لینک‌های رسمی مایکروسافت

۱۰.۲. کتاب‌ها (به شدت توصیه می‌شه)

کتاب نویسنده سطح
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 (پیشرفته)

۱۰.۴. تمرین‌های خودتون رو انجام بدید

  1. یک ConcurrentDictionary-based cache بسازید که از دیتابیس بخونه.
  2. یک rate-limiter پیاده‌سازی کنید که از Interlocked استفاده کنه.
  3. یک producer-consumer با Channel بسازید که بتواند 1M پیام در ثانیه پردازش کنه.
  4. در 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:

  1. مقدار location رو به‌صورت اتومیک می‌خونه.
  2. اگر با comparand برابر بود، value رو توش می‌نویسه.
  3. در هر دو حالت، مقدار قدیمی رو برمی‌گردونه (نه جدید).

مثال ۱: شمارنده امن

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 رو برمی‌گردونه.

گام به گام:

  1. Semaphore یک counting lock است (چند Thread می‌تونن هم‌زمان وارد بشن).
  2. Wait یک perm می‌گیره (اگه موجود نباشه صبر می‌کنه).
  3. Release یک perm رو برمی‌گردونه (هر Thread که تموم شد باید Release بزنه).
  4. وقتی 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 حاوی تمام مثال‌های این آموزش در فصل بعدی قرار داده می‌شه.

Rejoining the server...

Rejoin failed... trying again in seconds.

Failed to rejoin.
Please retry or reload the page.

The session has been paused by the server.

Failed to resume the session.
Please retry or reload the page.