C#线程队列用法实例分析

C#线程队列用法实例分析

1. 什么是线程队列

线程队列指的是一种数据结构，它遵循“先进先出（FIFO）”的原则，即第一个入队的元素也会是第一个被出队的元素。在C#中，我们可以使用Queue<T>类来实现线程队列。

2. 线程队列的主要用途

线程队列常用于多线程编程中，以便按照一定顺序访问共享资源，避免数据竞争等多线程并发问题。

3. C#中线程队列用法示例

3.1 实现生产者-消费者模型

生产者-消费者模型是常见的多线程模型，其中生产者线程负责将数据加入队列，而消费者线程从队列中取出数据进行处理。

下面是C#中生产者-消费者模型的示例代码：

using System;
using System.Collections.Generic;
using System.Threading;

class Program
{
    static Queue<int> queue = new Queue<int>();
    static int maxSize = 10;
    static object lockObj = new object();

    static void Main(string[] args)
    {
        Thread producer = new Thread(Producer);
        Thread consumer = new Thread(Consumer);

        producer.Start();
        consumer.Start();

        producer.Join();
        consumer.Join();
    }

    static void Producer(object o)
    {
        Random random = new Random();

        while (true)
        {
            lock (lockObj)
            {
                while (queue.Count >= maxSize)
                {
                    Monitor.Wait(lockObj);
                }

                int data = random.Next(100);
                queue.Enqueue(data);
                Console.WriteLine($"生产者生产了{data}，当前队列长度为{queue.Count}");

                Monitor.Pulse(lockObj);
            }

            Thread.Sleep(1000);
        }
    }

    static void Consumer(object o)
    {
        while (true)
        {
            lock (lockObj)
            {
                while (queue.Count == 0)
                {
                    Monitor.Wait(lockObj);
                }

                int data = queue.Dequeue();
                Console.WriteLine($"消费者消费了{data}，当前队列长度为{queue.Count}");

                Monitor.Pulse(lockObj);
            }

            Thread.Sleep(500);
        }
    }
}

3.2 实现多个线程依次执行

在某些场景下，我们需要确保多个线程按照一定的顺序执行，这时可以使用线程队列来实现任务调度。

下面是C#中线程队列用法的示例代码：

using System;
using System.Collections.Generic;
using System.Threading;

class Program
{
    static Queue<Action> queue = new Queue<Action>();
    static object lockObj = new object();

    static void Main(string[] args)
    {
        Thread t1 = new Thread(() => Print("1"));
        Thread t2 = new Thread(() => Print("2"));
        Thread t3 = new Thread(() => Print("3"));

        t1.Start();
        t2.Start();
        t3.Start();

        t1.Join();
        t2.Join();
        t3.Join();
    }

    static void Print(string str)
    {
        lock (lockObj)
        {
            queue.Enqueue(() => Console.Write($"{str}-1 "));
            queue.Enqueue(() => Console.Write($"{str}-2 "));
            queue.Enqueue(() => Console.Write($"{str}-3 "));
        }

        while (true)
        {
            Action task = null;

            lock (lockObj)
            {
                if (queue.Count > 0)
                {
                    task = queue.Dequeue();
                }
            }

            if (task != null)
            {
                task.Invoke();
            }
            else
            {
                Thread.Sleep(10);
            }
        }
    }
}

在上面的示例中，我们启动了三个线程t1、t2和t3。每个线程执行时，都将三个任务添加到任务队列中。在每个线程的无限循环中，我们从任务队列中取出任务并执行，从而保证三个任务按照顺序依次执行。