‫نحوه بهبود مدیریت حافظه «آرایه‌های بسیار بزرگ» در برنامه‌های دات‌نتی

• نسل صفر (Generation 0): این نسل، محل تولد تمام اشیاء جدید است. عملیات پاک‌سازی (Collection) در این نسل بسیار سریع و مکرر رخ می‌دهد. از آنجایی که بیشتر اشیاء عمر کوتاهی دارند، در همین مرحله اولیه از بین می‌روند که بهینه‌ترین حالت ممکن است.
• نسل یک (Generation 1): اشیائی که از پاک‌سازی نسل صفر جان سالم به در می‌برند، به نسل یک ارتقاء پیدا می‌کنند. این نسل نقش یک بافر را ایفا می‌کند و عملیات پاک‌سازی در آن کمتر از نسل صفر رخ می‌دهد.
• نسل دو (Generation 2): اشیائی که برای مدت طولانی‌تری زنده می‌مانند، نهایتاً به نسل دو منتقل می‌شوند. این نسل محل زندگی اشیاء با طول عمر بالاست. عملیات پاک‌سازی در این نسل به ندرت اتفاق می‌افتد اما بسیار هزینه‌بر و زمان‌بر است، زیرا نیازمند بررسی کل گراف اشیاء زنده در برنامه است.

• چرخه پاک‌سازی پرهزینه: پاک‌سازی LOH تنها همزمان با یک پاک‌سازی کامل نسل دو (Full GC) انجام می‌شود که خود پرهزینه‌ترین نوع پاک‌سازی است.
• عدم فشرده‌سازی پیش‌فرض: برخلاف هیپ اشیاء کوچک (Small Object Heap یا SOH)، حافظه LOH به طور پیش‌فرض فشرده‌سازی (Compaction) نمی‌شود. این یعنی پس از آزادسازی یک شیء بزرگ، فضای خالی آن باقی می‌ماند. با گذشت زمان و تکرار تخصیص و آزادسازی اشیاء بزرگ با اندازه‌های مختلف، این فضاها به حفره‌های خالی در سراسر LOH تبدیل می‌شوند. این پدیده که پارگی حافظه (Fragmentation) نام دارد، یکی از خطرناک‌ترین مشکلات عملکردی است.

public class MarketDataProcessor
{
    public void ProcessDailyData(IEnumerable<MarketTick> ticks)
    {
        // این کد بسته به تعداد تیک‌ها، باعث فشار بر LOH می‌شود
        var tickArray = ticks.ToArray();
        
        // تخصیص‌های بالقوه در LOH
        var priceData = new decimal[tickArray.Length]; 
        var volumeData = new long[tickArray.Length];

        // منطق پردازش که روی آرایه‌های بزرگ کار می‌کند
        for (int i = 0; i < tickArray.Length; i++)
        {
            priceData[i] = tickArray[i].Price;
            volumeData[i] = tickArray[i].Volume;
        }

        // آرایه‌ها پس از پردازش، کاندید پاک‌سازی می‌شوند
        // اما این پاک‌سازی تا زمان وقوع GC نسل دو به تعویق می‌افتد
    }
}

public class OptimizedMarketDataProcessor
{
    private readonly ArrayPool<decimal> _decimalPool = ArrayPool<decimal>.Shared;
    private readonly ArrayPool<long> _longPool = ArrayPool<long>.Shared;

    public void ProcessDailyData(IEnumerable<MarketTick> ticks)
    {
        var tickList = ticks.ToList(); // برای دسترسی به تعداد
        var count = tickList.Count;
        
        // آرایه‌ها از استخر مشترک اجاره می‌شوند
        var priceData = _decimalPool.Rent(count);
        var volumeData = _longPool.Rent(count);
        
        try
        {
            for (int i = 0; i < count; i++)
            {
                priceData[i] = tickList[i].Price;
                volumeData[i] = tickList[i].Volume;
            }
            
            // منطق پردازش با استفاده از آرایه‌های اجاره‌ای
        }
        finally
        {
            // تضمین بازگشت آرایه‌ها به استخر حتی در صورت بروز خطا
            _decimalPool.Return(priceData);
            _longPool.Return(volumeData);
        }
    }
}

public class StreamingMarketDataProcessor
{
    public async Task ProcessDailyDataAsync(IAsyncEnumerable<MarketTick> ticks)
    {
        // اندازه‌ای انتخاب شده که از LOH اجتناب شود
        const int batchSize = 1000; 
        var batch = new List<MarketTick>(batchSize);
        
        await foreach (var tick in ticks)
        {
            batch.Add(tick);
            
            if (batch.Count >= batchSize)
            {
                ProcessBatch(batch);
                batch.Clear(); // استفاده مجدد از همان نمونه List
            }
        }
        
        // پردازش آخرین دسته باقی‌مانده
        if (batch.Count > 0)
        {
            ProcessBatch(batch);
        }
    }
    
    private void ProcessBatch(List<MarketTick> batch)
    {
        // پردازش دسته‌های کوچکتر که در هیپ اشیاء کوچک (SOH) باقی می‌مانند
        foreach (var tick in batch)
        {
            // منطق پردازش تیک‌های داده
        }
    }
}