Living in the Tech Avalanche Generation

public sealed class Singleton
{
    static Singleton _instance = null;
    static readonly object _padlock = new object();
    static List<int> _ThreadSafeCounterList = new List<int>();
    static readonly Guid _instanceId = Guid.NewGuid();

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            lock (_padlock)
            {
                if (_instance == null)
                {
                    _instance = new Singleton();
                }
                return _instance;
            }
        }
    }

    public List<int> ThreadSafeCounterList
    {
        get
        {
            lock (_padlock)
            {
                return Singleton._ThreadSafeCounterList;
            }
        }
        set
        {
            lock (_padlock)
            {
                Singleton._ThreadSafeCounterList = value;
            }
        }
    }

    public Guid ID
    {
        get { return _instanceId; }
    }
}

class Program
{
    static AutoResetEvent evt;

    static void Main(string[] args)
    {
        Console.WriteLine(“Enter a key to begin the singleton workers”);
        Console.ReadLine();
        const int countup = 2000;
        for (int x = 0; x <= countup; x++)
        {
            //new up a background worker
            BackgroundWorker bg = new BackgroundWorker();
            //wire up the work handler delegate to do the computation
            bg.DoWork += new DoWorkEventHandler(bg_DoWork);
            //when x has reach the upper boundary of the loop
            //subscribe to the event that fires when the
            //work handler has completed its work (will subscribe)
            //to the last thread dialled up via the bg worker
            if (x == countup)
            {
                //last bg worker thread - subscribed to its 
                //completed event to signal an end
                bg.RunWorkerCompleted +=
                    new RunWorkerCompletedEventHandler(bg_RunWorkerCompleted);
            }
            //run up a thread
            bg.RunWorkerAsync(x);
        }
        //wait until blocks the current thread (main thread)
        //until signaled - will pause here..
        evt = new AutoResetEvent(false);
        evt.WaitOne();
    }

    static void bg_RunWorkerCompleted(object sender,
        RunWorkerCompletedEventArgs e)
    {
        Console.WriteLine(“Start reading of the list in “ +
            “the order the items were written.”);
        Console.ReadLine();

        //loop the list of integers and print 
        //them in order they were inserted
        for (int i = 0; i < Singleton.Instance.
            ThreadSafeCounterList.Count; i++)
        {
            Console.WriteLine(Singleton.Instance.
                ThreadSafeCounterList[i].ToString());
        }

        //signal to the user the total processing figures
        Console.WriteLine(“TOTAL added to Thread safe List is : “ +
            Singleton.Instance.ThreadSafeCounterList.Count.ToString());

        //pause for user entry
        Console.ReadLine();

        //signal to the main thread to continue
        //and therefore exit.
        evt.Set();
    }

    static void bg_DoWork(object sender, DoWorkEventArgs e)
    {
        System.Threading.Thread.Sleep(10);

        Console.WriteLine(“Added “ + e.Argument.ToString() +
            ” by thread with hashcode “ + Thread.CurrentThread.GetHashCode() +
            “\tto instance ID:\t” + Singleton.Instance.ID.ToString());

        //add the integer to the list
        Singleton.Instance.ThreadSafeCounterList.Add((int)e.Argument);

        //give back a time slice so the other threads get a piece
        System.Threading.Thread.Sleep(10);

        //write out to the window when you find 
        //the same integer that was just added
        //because a time slice was given back to
        //the OS task scheduler, another thread
        //may be processing, so the found integer 
        //and thread hashcode will not necessarily
        //print in order.
        Console.WriteLine(“Found “ + Singleton.Instance.
            ThreadSafeCounterList.Find(
            delegate(int findInt)
            {
                if (findInt == (int)e.Argument)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }).ToString()
                + ” by thread with hashcode “ +
                Thread.CurrentThread.GetHashCode() +
                “\tto instance ID:\t” +
                Singleton.Instance.ID.ToString());
    }
}