Phương thức Queue.Synchronized() trong C#

Phương thức Queue.Synchronized() trong C# được dùng để trả về một Queue mới bao bọc (wrap) queue gốc, cung cấp truy xuất an toàn cho đa luồng (thread-safe).

Cú pháp

public static System.Collections.Queue Synchronized(System.Collections.Queue queue);

• queue: Queue non-generic cần đồng bộ hóa.

Trả về: Wrapper Queue thread-safe quanh queue gốc.

Ví dụ 1: Kiểm tra IsSynchronized

using System;
using System.Collections;

public class Demo
{
    public static void Main()
    {
        Queue queue = new Queue();
        queue.Enqueue("AB");
        queue.Enqueue("BC");
        queue.Enqueue("CD");
        queue.Enqueue("DE");
        queue.Enqueue("EF");
        queue.Enqueue("FG");
        queue.Enqueue("GH");
        queue.Enqueue("HI");

        Console.WriteLine("Queue...");
        IEnumerator demoEnum = queue.GetEnumerator();
        while (demoEnum.MoveNext())
        {
            Console.WriteLine(demoEnum.Current);
        }

        Console.WriteLine("Queue đồng bộ? = " + queue.IsSynchronized); // False

        Queue queue2 = Queue.Synchronized(queue);
        Console.WriteLine("Queue đồng bộ sau Synchronized? = " + queue2.IsSynchronized); // True
    }
}

Kết quả

Queue...
AB
BC
CD
DE
EF
FG
GH
HI
Queue đồng bộ? = False
Queue đồng bộ sau Synchronized? = True

Ví dụ 2: Synchronized với Queue số nguyên và CopyTo

using System;
using System.Collections;

public class Demo
{
    public static void Main()
    {
        Queue queue = new Queue();
        queue.Enqueue(100);
        queue.Enqueue(200);
        queue.Enqueue(300);

        Console.WriteLine("Queue đồng bộ? = " + queue.IsSynchronized); // False

        Queue queue2 = Queue.Synchronized(queue);
        Console.WriteLine("Queue đồng bộ bây giờ? = " + queue2.IsSynchronized); // True

        Console.Write("Số lượng phần tử = ");
        Console.WriteLine(queue.Count);

        Console.WriteLine("Queue...");
        foreach (int i in queue)
        {
            Console.WriteLine(i);
        }

        Console.WriteLine("Có phần tử 500? = " + queue.Contains(500));

        // CopyTo mảng
        int[] intArr = new int[5];
        intArr[0] = 1;
        intArr[1] = 2;
        intArr[2] = 3;
        intArr[3] = 4;
        queue.CopyTo(intArr, 1); // Copy vào mảng từ index 1

        Console.WriteLine("\nQueue (gốc) - không đổi:");
        foreach (int i in queue) Console.WriteLine(i);

        Console.WriteLine("\nMảng (sau CopyTo):");
        foreach (int i in intArr) Console.WriteLine(i);
    }
}

Kết quả

Queue đồng bộ? = False
Queue đồng bộ bây giờ? = True
Số lượng phần tử = 3
Queue...
100
200
300
Có phần tử 500? = False
Queue (gốc) - không đổi:
100
200
300
Mảng (sau CopyTo):
1
100
200
300
0

Lưu ý quan trọng

• Queue.Synchronized chỉ áp dụng cho non-generic Queue (System.Collections.Queue).
• Không có Queue<T>.Synchronized() cho generic Queue.
• Để thread-safe với generic: dùng ConcurrentQueue<T> (System.Collections.Concurrent) hoặc lock thủ công.
• Wrapper synchronized khóa (lock) trên mọi phương thức (Enqueue, Dequeue, Peek, Count, Contains, CopyTo...).
• Duyệt (enumeration) trên wrapper synchronized KHÔNG an toàn luồng trừ khi khóa thủ công:

Queue syncQueue = Queue.Synchronized(queue);
lock (syncQueue.SyncRoot) // Phải khóa SyncRoot khi foreach
{
    foreach (var item in syncQueue) { ... }
}

Khuyên dùng: ConcurrentQueue<T>

using System.Collections.Concurrent;

var cq = new ConcurrentQueue();
cq.Enqueue(1); // Thread-safe
cq.TryDequeue(out int item); // Thread-safe, không ném exception

• Hiệu suất tốt hơn synchronized wrapper.
• API không block (non-blocking), phù hợp high-concurrency.
• Hỗ trợ IEnumerable an toàn (snapshot tại thời điểm GetEnumerator).