Multiple threads modifying a collection - multithreading

Question

I'm trying to learn about threads for an assignment for school, and I'm trying to get two threads to empty a collection. The code I came up with so far throws an exception, saying that the collection got modified.
First I had a while loop in the locked code part, but then (of course ;-)) only one thread empties the collection.
My question is, how can I have a loop in which the threads both take turns in emptying the collection?
class Program
{
private static List<int> containers = new List<int>();
static void Main(string[] args)
{
for (int i = 0; i < 100; i++)
{
containers.Add(i);
}
Thread t1 = new Thread(() => { foreach (int container in containers) { GeefContainer(); } });
t1.Name = "Kraan 1";
t1.Start();
Thread t2 = new Thread(() => { foreach (int container in containers) { GeefContainer(); } });
t2.Name = "Kraan 2";
t2.Start();
Console.Write("Press any key to continue...");
Console.Read();
}
static void GeefContainer()
{
lock (containers)
{
int containerNummer = containers.Count - 1;
//Container container = containers[containerNummer];
//Console.Write("Container {0} opgehaald... Overladen", containerNummer);
Console.WriteLine("Schip: Container {0} gegeven aan {1}", containerNummer, Thread.CurrentThread.Name);
//Gevaarlijk, want methode aanroepen kan klappen
containers.RemoveAt(containerNummer);
}
}
}

Answer 1

I assume you are not allowed to use any of the ThreadSafe collections found in the System.Collections.Concurrent namespace.
You need to gain exclusive access to the containers collection when checking if there are still entries left. Yet, you don't want 1 thread to take exclusive control removing all entries before releasing its lock. Monitor.Pulse can be used to allow other threads waiting to lock the container to 'go first'. Try the following implementation of GeefContainers:
static void GeefContainer()
{
lock (containers)
{
while (containers.Any()) // using linq, similar to: while(container.Count > 0)
{
containers.RemoveAt(0); // remove the first element
// allow other threads to take control
Monitor.Pulse(containers); // http://msdn.microsoft.com/en-us/library/system.threading.monitor.pulse.aspx
// Wait for a pulse from the other thread
Monitor.Wait(container);
}
}
}
Oh, and remove your looping logic from:
Thread t2 = new Thread(() => { foreach (int container in containers) { GeefContainer(); } });
Simply invoking GeefContainer is enough.
This can be visualized in the following way:
Thread 1 gains a lock to 'collections'
Thread 2 is blocked since it's waiting for an exclusive lock to 'collections'
Thread 1 removes an entry from 'collections'
Thread 1 releases it's lock on 'collections' and tries to gain a new exclusive lock
Thread 2 gains a lock to 'collections'
Thread 2 removes an entry from 'collections'
Thread 2 releases it's lock on 'collections' and tries to gain a new exclusive lock
Thread 1 gains a lock to 'collections'
etc

Answer 2

The exception you are seeing is being thrown by the enumerator. Enumerators on standard collections have checks to make sure the collection was not modified in the middle of an enumeration operation (via foreach in your case).
Since you want to have your threads alternate removing from the collection then you will need some kind of mechanism that allows the threads to signal each other. We also have to be careful not to access the collection from multiple collections at the same time. Not even the Count property is safe to use without synchronization. The Barrier class makes the signaling really easy. A simple lock will suffice for the synchronization. Here is how I would do this.
public class Program
{
public static void Main(string[] args)
{
var containers = new List<int>();
for (int i = 0; i < 100; i++)
{
containers.Add(i);
}
var barrier = new Barrier(0);
var t1 = new Thread(() => GeefContainers(containers, barrier));
t1.Name = "Thread 1";
t1.Start();
var t2 = new Thread(() => GeefContainers(containers, barrier));
t2.Name = "Thread 2";
t2.Start();
Console.Write("Press any key to continue...");
Console.Read();
}
private static void GeefContainers(List<int> list, Barrier barrier)
{
barrier.AddParticipant();
while (true)
{
lock (list)
{
if (list.Count > 0)
{
list.RemoveAt(0);
Console.WriteLine(Thread.CurrentThread.Name + ": Count = " + list.Count.ToString());
}
else
{
break;
}
}
barrier.SignalAndWait();
}
barrier.RemoveParticipant();
}
}
The Barrier class basically causes this to happen over and over again.
|----| |----| |----|
| T1 |-->| |-->| T1 |-->| |-->| T1 |
|----| | | |----| | | |----|
|-->(B)-->| |-->(B)-->|
|----| | | |----| | | |----|
| T2 |-->| |-->| T2 |-->| |-->| T2 |
|----| |----| |----|
In the above diagram T1 and T2 represent the remove operations on threads 1 and 2 respectively. (B) represents a call to Barrier.SignalAndWait.

Answer 3

First, change your thred definition as follows:
new Thread(() => { while(containers.Count>0) { GeefContainer(); } });
Then, rewrite GeefContainer() as follows to avoid exceptions:
static void GeefContainer()
{
lock (containers)
{
int containerNummer = containers.Count - 1;
if(containerNummer>=0)
{
//Container container = containers[containerNummer];
//Console.Write("Container {0} opgehaald... Overladen", containerNummer);
Console.WriteLine("Schip: Container {0} gegeven aan {1}", containerNummer, Thread.CurrentThread.Name);
//Gevaarlijk, want methode aanroepen kan klappen
containers.RemoveAt(containerNummer);
}
}
}

Answer 4

What if you modify your threads as follows? That way, both threads should get some time to perform actions on the collection.
Thread t1 = new Thread(() => {
while (containers.Count > 0)
{
GeefContainer();
Thread.Sleep(150);
}});
t1.Name = "Kraan 1";
t1.Start();
Thread t2 = new Thread(() => {
while (containers.Count > 0)
{
GeefContainer();
Thread.Sleep(130);
}});
t2.Name = "Kraan 2";
t2.Start();