Tràn bộ nhớ (Memory Overflow) xảy ra khi ứng dụng yêu cầu lượng bộ nhớ vượt quá giới hạn mà hệ điều hành cấp phát, dẫn đến lỗi "Out of memory". Nguyên nhân có thể do phần cứng yếu hoặc logic mã nguồn tiêu thụ bộ nhớ quá mức.

Rò rỉ bộ nhớ (Memory Leak) là tình trạng ứng dụng không giải phóng được các vùng nhớ không còn sử dụng do lỗi thiết kế. Khi lượng bộ nhớ không thể thu hồi tích lũy ngày càng nhiều, hiệu suất chương trình sẽ giảm sút và cuối cùng dẫn đến tràn bộ nhớ.

Công cụ giám sát và phát hiện

Để theo dõi và phát hiện rò rỉ bộ nhớ trong các ứng dụng .NET, có thể sử dụng các công cụ chuyên dụng như:

• .NET Memory Profiler (SciTech Software)
• YourKit .NET Profiler
• AQTime (AutomatedQA)

Ngoài ra, trong quá trình kiểm thử đơn vị (Unit Testing), bạn có thể chủ động kiểm tra lượng bộ nhớ đang được sử dụng thông qua hàm GC.GetTotalMemory(true) bằng cách in kết quả ra console.

Các nguyên nhân phổ biến và cách khắc phục

1. Sự kiện không được hủy đăng ký

Khi một đối tượng (listener) đăng ký lắng nghe sự kiện từ một đối tượng khác (publisher), publisher sẽ giữ một tham chiếu đến listener. Nếu listener này không được hủy đăng ký trước khi bị hủy, garbage collector (GC) sẽ không thể thu hồi bộ nhớ của listener do vẫn còn tham chiếu từ publisher.

Tình trạng này đặc biệt nghiêm trọng khi publisher là một đối tượng có vòng đời dài, chẳng hạn như biến tĩnh (static) hoặc đối tượng Singleton. Ví dụ, lớp SystemEvents trong .NET chứa các sự kiện tĩnh. Khi bạn đăng ký một phương thức vào sự kiện tĩnh này, đối tượng chứa phương thức sẽ bị neo lại và không bao giờ được giải phóng.

using System;
using Microsoft.Win32;

public class EventObserver : IDisposable
{
    // Cấp phát một khối bộ nhớ lớn để dễ dàng quan sát sự thay đổi
    private byte[] dataBlock = new byte[1_000_000];

    public EventObserver()
    {
        // Đăng ký sự kiện tĩnh, gây ra rò rỉ nếu không hủy đăng ký
        SystemEvents.TimeChanged += TimeChangedCallback;
    }

    private void TimeChangedCallback(object sender, EventArgs e)
    {
        // Xử lý logic tại đây
    }

    public void Dispose()
    {
        // Hủy đăng ký sự kiện để cho phép GC thu hồi bộ nhớ
        SystemEvents.TimeChanged -= TimeChangedCallback;
    }
}

public class Program
{
    static void ShowMemoryUsage()
    {
        Console.WriteLine($"Total Memory: {GC.GetTotalMemory(true):N0} bytes");
    }

    static void Main()
    {
        ShowMemoryUsage();
        
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"--- Vòng lặp {i + 1} ---");
            
            // Sử dụng khối 'using' đảm bảo Dispose() được gọi
            using (var observer = new EventObserver())
            {
                // Mô phỏng thao tác
            }
            
            // Ép GC thu gom rác
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            
            ShowMemoryUsage();
        }
    }
}

Tương tự, trong các ứng dụng WinForms hoặc WPF, nếu một Form chính (MainForm) có vòng đời kéo dài suốt phiên làm việc và giữ tham chiếu đến một Form con qua sự kiện, Form con đó sẽ không được giải phóng bộ nhớ sau khi đóng.

using System;
using System.ComponentModel;
using System.Windows.Forms;

public partial class PrimaryForm : Form
{
    public event EventHandler StatusUpdated;

    public PrimaryForm()
    {
        InitializeComponent();
    }

    private void btnOpenChild_Click(object sender, EventArgs e)
    {
        var childForm = new SecondaryForm();
        
        // MainForm nắm giữ tham chiếu của SecondaryForm qua sự kiện
        this.StatusUpdated += childForm.UpdateStatus;
        
        childForm.ShowDialog();
        
        // Nếu không hủy đăng ký tại đây, childForm sẽ không bị thu hồi
        // this.StatusUpdated -= childForm.UpdateStatus;
        
        GC.Collect();
        MessageBox.Show($"Bộ nhớ hiện tại: {GC.GetTotalMemory(true):N0} bytes");
    }
}

public partial class SecondaryForm : Form
{
    public SecondaryForm()
    {
        InitializeComponent();
    }

    public void UpdateStatus(object sender, EventArgs e)
    {
        // Logic xử lý
    }
}

2. Sử dụng biến tĩnh

Các trường tĩnh không bao giờ bị thu hồi bởi GC trong suốt vòng đời của AppDomain. Do đó, nếu một biến tĩnh chứa tham chiếu đến các đối tượng phức tạp hoặc tập hợp (collections) mà không được dọn dẹp thủ công, nó sẽ dẫn đến rò rỉ bộ nhớ. Mẫu thiết kế Singleton là một ví dụ điển hình cần lưu ý về vấn đề này.

3. Tài nguyên không được quản lý

Các tài nguyên như kết nối cơ sở dữ liệu, file streams, hoặc các handle của hệ điều hành không nằm dưới sự quản lý của CLR. Việc không giải phóng chúng (thông qua Dispose() hoặc Close()) sẽ khiến bộ nhớ rò rỉ qua từng lần thực thi.

4. Triển khai phương thức Dispose không triệt để

Ngay cả khi đã gọi Dispose(), nếu phương thức này không được thực hiện đúng đắn — ví dụ: không hủy các sự kiện đã đăng ký, không gọi Dispose cho các đối tượng con — thì rò rỉ bộ nhớ vẫn xảy ra. Cần tuân thủ mẫu IDisposable một cách nghiêm ngặt.

5. Truy vấn dữ liệu khổng lồ

Việc kéo hàng triệu bản ghi từ cơ sở dữ liệu vào các đối tượng DataTable hoặc DataSet trong bộ nhớ không chỉ gây tràn bộ nhớ mà còn làm giảm hiệu năng. Giải pháp tối ưu cho trường hợp này là áp dụng phân trang (pagination) hoặc sử dụng DbDataReader để đọc dữ liệu theo luồng (streaming) thay vì tải toàn bộ cùng lúc.