Question

Here is some code that perpetually generate GUIDs. I’ve written it to learn about threading. In it you’ll notice that I’ve got a lock around where I generate GUIDs and enqueue them even though the ConcurrentQueue is thread safe. It’s because my actual code will need to use NHibernate and so I must make sure that only one thread gets to fill the queue.

While I monitor this code in Task Manager, I notice the process drops the number of threads from 18 (on my machine) to 14 but no less. Is this because my code isn’t good?

Also can someone refactor this if they see fit? I love shorter code.

class Program
{
    ConcurrentNewsBreaker Breaker;

    static void Main(string[] args)
    {
        new Program().Execute();

        Console.Read();
    }

    public void Execute()
    {
        Breaker = new ConcurrentNewsBreaker();
        QueueSome();
    }

    public void QueueSome()
    {
        ThreadPool.QueueUserWorkItem(DoExecute);
    }

    public void DoExecute(Object State)
    {
        String Id = Breaker.Pop();
        Console.WriteLine(String.Format("- {0} {1}", Thread.CurrentThread.ManagedThreadId, Breaker.Pop()));

        if (Breaker.Any())
            QueueSome();
        else
            Console.WriteLine(String.Format("- {0} XXXX ", Thread.CurrentThread.ManagedThreadId));            
    }
}


public class ConcurrentNewsBreaker
{
    static readonly Object LockObject = new Object();

    ConcurrentQueue<String> Store = new ConcurrentQueue<String>();

    public String Pop()
    {
        String Result = null;
        if (Any())
            Store.TryDequeue(out Result);
        return Result;
    }

    public Boolean Any()
    {
        if (!Store.Any())
        {
            Task FillTask = new Task(FillupTheQueue, Store);
            FillTask.Start();
            FillTask.Wait();
        }

        return Store.Any();
    }

    private void FillupTheQueue(Object StoreObject)
    {
        ConcurrentQueue<String> Store = StoreObject as ConcurrentQueue<String>;
        lock(LockObject)
        {
            for(Int32 i = 0; i < 100; i++)
                Store.Enqueue(Guid.NewGuid().ToString());            
        }
    }
}

Answer 1

You are using .NET’s ThreadPool so .NET/Windows manages the number of threads based on the amount of work waiting to be processed.