Manage Threads Relationship in C#

Question

Now, i am learning multi-threading and usage of it in C#. So, i face the problem as below: (Sorry for my so simple question)

Suppose that, we have two classes named Producer and Consumer. Producer task is producing 4 numbers while program running and Consumer task is consuming and using those numbers and return the sum of them at the end of program.

Consumer Class definition:

class Consumer
{
    private HoldInteger sharedLocation;
    private Random randomSleepTime;

    public Consumer(HoldInteger shared, Random random)
    {
        sharedLocation = shared;
        randomSleepTime = random;
    }

    public void Consume()
    {
        int sum = 0;

        for (int i = 1; i <= 4; i++)
        {
            Thread.Sleep(randomSleepTime.Next(1, 3000));
            sum += sharedLocation.Buffer;
        }
    }
}

and the definition of Producer Class is as below :

class Producer
{
    private HoldInteger sharedLocation;
    private Random randomSleepTime;

    public Producer(HoldInteger shared, Random random)
    {
        sharedLocation = shared;
        randomSleepTime = random;
    }

    public void Produce()
    {
        for (int i = 1; i <= 4; i++)
        {
            Thread.Sleep(randomSleepTime.Next(1, 3000));
            sharedLocation.Buffer = i;
        }
    }
}

And also, we have HoldInteger class contains Buffer variable that producer write this variable and consumer read from that. I combine these classes and program the below code in my main method:

static void Main(string[] args)
{
   HoldInteger holdInteger = new HoldInteger();
   Random random = new Random();

   Producer producer = new Producer(holdInteger, random);

   Consumer consumer = new Consumer(holdInteger, random);

   Thread producerThread = new Thread(new ThreadStart(producer.Produce));
   producerThread.Name = "producer";

   Thread consumerThread = new Thread(new ThreadStart(consumer.Consume));
   consumerThread.Name = "consumer";

   producerThread.Start();
   consumerThread.Start();
}

So, my question is that How can i manage this relationship With Low Memory and Time Wasting ?

Please note that, these threads management code will be placed in HoldInteger class body.

Thanks for your attention.

score 4 · Accepted Answer · edited May 23 '17 at 12:26

I would replace the HoldInteger class with a BlockingQueue, you can find an implementation here and for more details on the reason behind the implementation, check this question. I think .NET 4.0 might have a blocking queue too. This approach will subsequently make things a lot easier to manage:

class Producer
{
    //...

    public void Produce()
    {
        for (int i = 1; i <= 4; i++)
        {
            Thread.Sleep(randomSleepTime.Next(1, 3000));
            blockingIntQueue.Enqueue(i);
        }
    }
}

Your consumer will look like this now:

class Consumer
{
    //...

    public void Consume()
    {
        int value = 0;
        for (int i = 1; i <= 4; i++)
        {
            if( blockingIntQueue.TryDequeue(out value) )
            {
                sum += value;
            }
        }
    }
}

However, if you want to keep the HoldInteger (if this is some sort of requirement), then you can place the blocking queue inside the HoldIntegerUnsynchronized class instead of having a buffer (should be trivial to do) and you will achieve the same result.

Note: with this approach you no longer have to worry about missing a value or reading a stale value because the threads don't wake up at exactly the right time. Here is the potential problem with using a "buffer":

Even if your integer holder does handle the underlying "buffer" safely, you are still not guaranteed that you will get all the integers that you want. Take this into consideration:

Case 1

Producer wakes up and writes integer.
Consumer wakes up and reads integer.

Consumer wakes up and reads integer.
Producer wakes up and writes integer.

Case 2

Consumer wakes reads integer.
Producer wakes up and writes integer.

Producer wakes up and writes integer.
Consumer wakes up and reads integer.

Since the timer is not precise enough, this sort of thing is entirely possible and in the first case it will cause the consumer to read a stale value, while in the second case it will cause the consumer to miss a value.

score 1 · Answer 2 · answered Aug 23 '11 at 21:26

You can do something like

class HoldIntegerUnsynchronized {
    int buffer;
    object syncLock = new object();
    bool goodToRead = false;
    bool goodToWrite = true;

    public int Buffer {
       get {
           lock (syncLock) {
               while (!goodToWrite)
                   Monitor.Wait(syncLock);
               buffer = value;
               goodToWrite = false;
               goodToRead = true;
               Monitor.Pulse(syncLock);
           }
       }
       set {
           lock (syncLock) {
               while (!goodToRead)
                   Monitor.Wait(syncLock);
               int toReturn = buffer;
               goodToWrite = true;
               goodToRead = false;
               Monitor.Pulse(syncLock);
               return toReturn;
           }
       }
    }
}

Note I haven't tested this code!

Yes, i used a way like this, but i think it can waste the run time. Because if the producer thread produces values faster than the consumer can consume those values, then the producer thread waits for the consumer, because there are no other locations in memory to place the next value. — Hossein Mobasher, Aug 23 '11 at 21:49

Manage Threads Relationship in C#

2 Answers2