C# 如何将数据从一个线程传递到其他三个线程？

我必须编写一个由四个线程组成的应用程序：

线程生成一些数据（生产者线程）

线程从生产者线程获取数据并执行

Action1（数据）

线程从生产者线程获取数据并执行

Action2（数据）

线程从生产者线程获取数据并执行

Action3（数据）

---

如何将相同的数据传递给所有三个使用线程？我仅限于.NET 3.0库，也就是说，我不能使用ConcurrentQueues之类的东西。

一个选项是，只要让生产者在事件生成数据时触发事件，就可以让任意数量的不同使用者订阅事件，并在线程池线程中根据该数据排队完成工作

public class Producer
{
    public event Action<Data> DataProduced;

    public void Produce()
    {
        while (true)
        {
            Thread.Sleep(1000);//placeholder for real work
            DataProduced(new Data());//populate with real data
        }
    }
}

---

一种选择是，只要让生产者在事件生成数据时触发事件，就可以让任意数量的不同使用者订阅事件，并将基于该数据的工作排队到线程池线程中

public class Producer
{
    public event Action<Data> DataProduced;

    public void Produce()
    {
        while (true)
        {
            Thread.Sleep(1000);//placeholder for real work
            DataProduced(new Data());//populate with real data
        }
    }
}

---

一种选择是，只要让生产者在事件生成数据时触发事件，就可以让任意数量的不同使用者订阅事件，并将基于该数据的工作排队到线程池线程中

public class Producer
{
    public event Action<Data> DataProduced;

    public void Produce()
    {
        while (true)
        {
            Thread.Sleep(1000);//placeholder for real work
            DataProduced(new Data());//populate with real data
        }
    }
}

---

一种选择是，只要让生产者在事件生成数据时触发事件，就可以让任意数量的不同使用者订阅事件，并将基于该数据的工作排队到线程池线程中

public class Producer
{
    public event Action<Data> DataProduced;

    public void Produce()
    {
        while (true)
        {
            Thread.Sleep(1000);//placeholder for real work
            DataProduced(new Data());//populate with real data
        }
    }
}

---

从线程继承所有四次。使用属性或setter扩展派生，甚至在ctor中，您可以在t1完成时传递数据。然后，在将返回的数据从t1传递给派生之后，开始他们的工作。

我不能使用ConcurrentQueues之类的东西。

然后使用标准字典/队列/列表，但锁定所有读和写操作writes@L.B其实没那么简单。执行操作“等待，直到你有另一个项目给我，然后再给我”是

BlockingCollection

给你的，这使得这个操作相当不错。要重新实现它，需要的不仅仅是一个

锁

。使用属性或setter扩展派生，甚至在ctor中，您可以在t1完成时传递数据。然后，在将返回的数据从t1传递给派生之后，开始他们的工作。

我不能使用ConcurrentQueues之类的东西。

然后使用标准字典/队列/列表，但锁定所有读和写操作writes@L.B其实没那么简单。执行操作“等待，直到你有另一个项目给我，然后再给我”是

BlockingCollection

给你的，这使得这个操作相当不错。要重新实现它，需要的不仅仅是一个

锁

。使用属性或setter扩展派生，甚至在ctor中，您可以在t1完成时传递数据。然后，在将返回的数据从t1传递给派生之后，开始他们的工作。

我不能使用ConcurrentQueues之类的东西。

然后使用标准字典/队列/列表，但锁定所有读和写操作writes@L.B其实没那么简单。执行操作“等待，直到你有另一个项目给我，然后再给我”是

BlockingCollection

给你的，这使得这个操作相当不错。要重新实现它，需要的不仅仅是一个

锁

。使用属性或setter扩展派生，甚至在ctor中，您可以在t1完成时传递数据。然后，在将返回的数据从t1传递给派生之后，开始他们的工作。

我不能使用ConcurrentQueues之类的东西。

然后使用标准字典/队列/列表，但锁定所有读和写操作writes@L.B其实没那么简单。执行操作“等待，直到你有另一个项目给我，然后再给我”是

BlockingCollection

给你的，这使得这个操作相当不错。要重新实现这一点，需要的不仅仅是一个

锁。