C# 具有额外线程的生产者-消费者队列，用于定期备份数据

我试图实现一个具有多个生产者和一个消费者的并发生产者/消费者队列：生产者将一些数据添加到

队列

，消费者将这些数据从队列中排出，以更新集合。必须定期将此集合备份到新文件。为此，我创建了一个自定义的可序列化集合：可以使用

DataContractSerializer

执行序列化

• 队列仅在使用者和生产者之间共享，因此必须管理对此队列的访问以避免竞争条件
• 自定义集合在使用者和备份线程之间共享
• 备份线程可以使用对象定期激活：它可能最初由使用者调度，然后在每个备份过程结束时调度
• 最后，关闭方法应该停止生产者的排队，然后停止使用者，执行最后一次备份并处理计时器

一次退出一个项目可能效率不高，因此我考虑使用两个队列：当第一个队列已满时，生产者通过调用

Monitor.Pulse

通知消费者。消费者一收到通知，队列就被交换，因此当生产者将新项目排队时，消费者可以处理以前的项目

我写的样本似乎工作正常。我认为它也是线程安全的，但我不确定这一点。下面的代码，为了简单起见，我使用了

队列

。为了简单起见，我还使用了

ArrayList

，而不是可序列化的集合

public class QueueManager
{
    private readonly int m_QueueMaxSize;
    private readonly TimeSpan m_BackupPeriod;

    private readonly object m_SyncRoot_1 = new object();
    private Queue<int> m_InputQueue = new Queue<int>();
    private bool m_Shutdown;
    private bool m_Pulsed;

    private readonly object m_SyncRoot_2 = new object();
    private ArrayList m_CustomCollection = new ArrayList();

    private Thread m_ConsumerThread;
    private Timer m_BackupThread;
    private WaitHandle m_Disposed;

    public QueueManager()
    {
        m_ConsumerThread = new Thread(Work) { IsBackground = true };

        m_QueueMaxSize = 7;
        m_BackupPeriod = TimeSpan.FromSeconds(30);
    }

    public void Run()
    {
        m_Shutdown = m_Pulsed = false;

        m_BackupThread = new Timer(DoBackup);
        m_Disposed = new AutoResetEvent(false);

        m_ConsumerThread.Start();
    }

    public void Shutdown()
    {
        lock (m_SyncRoot_1)
        {
            m_Shutdown = true;
            Console.WriteLine("Worker shutdown...");

            Monitor.Pulse(m_SyncRoot_1);
        }

        m_ConsumerThread.Join();
        WaitHandle.WaitAll(new WaitHandle[] { m_Disposed });

        if (m_InputQueue != null) { m_InputQueue.Clear(); }
        if (m_CustomCollection != null) { m_CustomCollection.Clear(); }

        Console.WriteLine("Worker stopped!");
    }

    public void Enqueue(int item)
    {
        lock (m_SyncRoot_1)
        {
            if (m_InputQueue.Count == m_QueueMaxSize)
            {
                if (!m_Pulsed)
                {
                    Monitor.Pulse(m_SyncRoot_1); // it notifies the consumer...
                    m_Pulsed = true;
                }
                Monitor.Wait(m_SyncRoot_1);  // ... and waits for Pulse
            }

            m_InputQueue.Enqueue(item);
            Console.WriteLine("{0}    \t {1} >", Thread.CurrentThread.Name, item.ToString("+000;-000;"));
        }
    }

    private void Work()
    {
        m_BackupThread.Change(m_BackupPeriod, TimeSpan.FromMilliseconds(-1));

        Queue<int> m_SwapQueueRef, m_WorkerQueue = new Queue<int>();

        Console.WriteLine("Worker started!");
        while (true)
        {
            lock (m_SyncRoot_1)
            {
                if (m_InputQueue.Count < m_QueueMaxSize && !m_Shutdown) Monitor.Wait(m_SyncRoot_1);

                Console.WriteLine("\nswapping...");
                m_SwapQueueRef = m_InputQueue;
                m_InputQueue = m_WorkerQueue;
                m_WorkerQueue = m_SwapQueueRef;

                m_Pulsed = false;
                Monitor.PulseAll(m_SyncRoot_1); // all producers are notified
            }

            Console.WriteLine("Worker\t      < {0}", String.Join(",", m_WorkerQueue.ToArray()));

            lock (m_SyncRoot_2)
            {
                Console.WriteLine("Updating custom dictionary...");
                foreach (int item in m_WorkerQueue)
                {
                    m_CustomCollection.Add(item);
                }
                Thread.Sleep(1000);
                Console.WriteLine("Custom dictionary updated successfully!");
            }

            if (m_Shutdown)
            {
                // schedule last backup
                m_BackupThread.Change(0, Timeout.Infinite);
                return;
            }
            m_WorkerQueue.Clear();
        }
    }

    private void DoBackup(object state)
    {
        try
        {
            lock (m_SyncRoot_2)
            {
                Console.WriteLine("Backup...");
                Thread.Sleep(2000);
                Console.WriteLine("Backup completed at {0}", DateTime.Now);
            }
        }
        finally
        {
            if (m_Shutdown) { m_BackupThread.Dispose(m_Disposed); }
            else { m_BackupThread.Change(m_BackupPeriod, TimeSpan.FromMilliseconds(-1)); }
        }
    }
}

---

我建议对生产者/消费者队列使用

BlockingCollection

。它是专门为此目的设计的。生产者使用

add

添加商品，消费者使用

Take

。如果没有要获取的项目，则它将阻止，直到添加一个项目。它已经被设计用于多线程环境，因此如果您只是使用这些方法，就不需要显式地使用任何锁或其他同步代码

public static void Main(string[] args)
{
    QueueManager queue = new QueueManager();

    var t1 = new Thread(() =>
    {
        for (int i = 0; i < 50; i++)
        {
            queue.Enqueue(i);
            Thread.Sleep(1500);
        }
    }) { Name = "t1" };

    var t2 = new Thread(() =>
    {
        for (int i = 0; i > -30; i--)
        {
            queue.Enqueue(i);
            Thread.Sleep(3000);
        }
    }) { Name = "t2" };

    t1.Start(); t2.Start(); queue.Run();
    t1.Join(); t2.Join(); queue.Shutdown();
    Console.ReadLine();

    var t3 = new Thread(() =>
    {
        for (int i = 0; i < 50; i++)
        {
            queue.Enqueue(i);
            Thread.Sleep(1000);
        }
    }) { Name = "t3" };

    var t4 = new Thread(() =>
    {
        for (int i = 0; i > -30; i--)
        {
            queue.Enqueue(i);
            Thread.Sleep(2000);
        }
    }) { Name = "t4" };

    t3.Start(); t4.Start(); queue.Run();
    t3.Join(); t4.Join(); queue.Shutdown();
    Console.ReadLine();
}