Question

Ok, So, I just started screwing around with threading, now it’s taking a bit of time to wrap my head around the concepts so i wrote a pretty simple test to see how much faster if faster at all printing out 20000 lines would be (and i figured it would be faster since i have a quad core processor?)

so first i wrote this, (this is how i would normally do the following):

System.DateTime startdate = DateTime.Now;
    for (int i = 0; i < 10000; ++i)
    {
        Console.WriteLine("Producing " + i);
        Console.WriteLine("\t\t\t\tConsuming " + i);
    }

    System.DateTime endtime = DateTime.Now;
    Console.WriteLine(a.startdate.Second + ":" + a.startdate.Millisecond + " to " + endtime.Second + ":" + endtime.Millisecond);

And then with threading:

public class Test
{
static ProducerConsumer queue;
public System.DateTime startdate = DateTime.Now;
static void Main()
{
    queue = new ProducerConsumer();
    new Thread(new ThreadStart(ConsumerJob)).Start();


    for (int i = 0; i < 10000; i++)
    {
        Console.WriteLine("Producing {0}", i);
        queue.Produce(i);

    }
    Test a = new Test();
}

static void ConsumerJob()
{
    Test a = new Test();
    for (int i = 0; i < 10000; i++)
    {
        object o = queue.Consume();
        Console.WriteLine("\t\t\t\tConsuming {0}", o);

    }
    System.DateTime endtime = DateTime.Now;

    Console.WriteLine(a.startdate.Second + ":" + a.startdate.Millisecond + " to " + endtime.Second + ":" + endtime.Millisecond);
}
}

public class ProducerConsumer
{
readonly object listLock = new object();
Queue queue = new Queue();

public void Produce(object o)
{
    lock (listLock)
    {
        queue.Enqueue(o);        
        Monitor.Pulse(listLock);
    }
}

public object Consume()
{
    lock (listLock)
    {
        while (queue.Count == 0)
        {
            Monitor.Wait(listLock);
        }
        return queue.Dequeue();
    }
}



}

Now, For some reason i assumed this would be faster, but after testing it 15 times, the median of the results is … a few milliseconds different in favor of non threading

Then i figured hey … maybe i should try it on a million Console.WriteLine’s, but the results were similar

am i doing something wrong ?

Answer 1

Writing to the console is internally synchronized. It is not parallel. It also causes cross-process communication.

In short: It is the worst possible benchmark I can think of 😉

Try benchmarking something real, something that you actually would want to speed up. It needs to be CPU bound and not internally synchronized.