How to make one producer, two consumers?

Question

How to create one producer and two consumers with thread and task?

I tried many things: blocking collection, monitor.wait(enter,exit,pulse), semaphore, but can't seem to get it working.

Here is thread start:

private void button1_Click(object sender, EventArgs e)
{
    Thread Producer = new Thread(new ThreadStart(Task_Producer));
    Thread Consumer = new Thread(new ThreadStart(Task_Consumer));
    Thread Consumer2 = new Thread(new ThreadStart(Task_Consumer2));
    Producer.start();
    Consumer.start();
    Consumer2.start();
}

Here is threads:

private Task task1;
private Task task2;
private Task task3;
void Task_Producer()
{
task1 = Task.Factory.StartNew(Producer_t);
}
void Task_Consumer()
{
task2 = Task.Factory.StartNew(Consumer_t);
}
void Task_Consumer2()
{
task3 = Task.Factory.StartNew(Consumer_t2);
}

Here is task:

int i=0;
int how_much_numbers=1000;
int number=0;
private void Producer_t()
{
   for (i = 0; i < how_much_numbers;i++)  
    {
     //number=random number;
    }
}
private void Consumer_t()
{
   while (i<how_much_numbers)
        {
        //Check if number is fibonaci
        }
}
private void Consumer_t2()
{
   while (i<how_much_numbers)
        {
        //Check if number is primary
        }
}

Answer 1

In this sample, threads and tasks are mixed, which is worse than wrong, it's useless as used to say one my teachers ;-)

Task.Factory.StartNew will have your code executed on a different thread. So from button1_Click, 3 threads will be started, and each one will push a new task to the thread pool through the task factory. At least one layer can be removed. Let say, for modernity's sake, remove the thread stuff and stick to the Task.Factory.StartNew, directly in the event handler.

According to this, the following code might do what you want :

public class ProducerConsumerTest
{
    private readonly BlockingCollection<int> _randomNumbersForFibonacci = new BlockingCollection<int>(10);
    private readonly BlockingCollection<int> _randomNumbersForPrime = new BlockingCollection<int>(10);

    int i = 0;
    int how_much_numbers = 20;
    int number = 0;
    private void Producer_t()
    {
        var random = new Random();

        for (i = 0; i < how_much_numbers; i++)
        {
            var randomNumber = random.Next();

            _randomNumbersForFibonacci.Add(randomNumber);
            _randomNumbersForPrime.Add(randomNumber);
        }
    }
    private void Consumer_t()
    {
        foreach (var randomNumber in _randomNumbersForFibonacci.GetConsumingEnumerable())
        {
            //Check if number is fibonaci
            Console.Out.WriteLine("IsFibonacci({0})", randomNumber);
        }
    }
    private void Consumer_t2()
    {
        foreach (var randomNumber in _randomNumbersForPrime.GetConsumingEnumerable())
        {
            //Check if number is primary
            Console.Out.WriteLine("IsPrime({0})", randomNumber);
        }
    }

    public void Run()
    {
        var producingTask = Task.Factory.StartNew(Producer_t);

        var fibonacciTask = Task.Factory.StartNew(Consumer_t);

        var primeTask = Task.Factory.StartNew(Consumer_t2);
    }
}

But you'll have to duplicate the collection to have every generated number analyzed by both tasks, because iterating through .GetConsumingEnumerable() removes the read element from the collection, so it can only be read once.