Question

I have a C# HttpListener that runs on a single thread and parses data sent to it by another program. My main problem is not all the data sent to the server is received. I only assume this is due to the limitations of it being run on a single thread. I have searched high and low for a simple multi-threading solution so it may receive al the data sent to it, and came up empty handed. Any help in transforming this into a multi-threaded application would be much appreciated.

    private void frmMain_Load(object sender, EventArgs e)
    {
        Thread t = new Thread(new ThreadStart(ThreadProc));
        t.Start();
    }

    public static void ThreadProc()
    {
        while (true)
        {
            WebBot.SimpleListenerExample(new string[] { "http://localhost:13274/" });
            //Thread t = new Thread(new ThreadStart(ThreadProc));
            //t.Start();
            Application.DoEvents();
        }
    }

Answer 1

First thing first: verify that your hypothesis is indeed correct. You need to check:

1. How much data is sent
2. How much data is received
3. How long does it take to send the data
4. How long does it take to operate on the data

HTTP works over TCP, which generally guarantees delivery, so even if it will take a long time, your server should be getting all the incoming information.

That said, if you still want to make the process multi-threaded, I would recommend the following design:

1. One thread like you have right now (LISTENER THREAD), that accepts incoming data.
2. Another set of threads that will process the incoming data (WORKER THREADS).
3. The listener thread will only receive the data and place it in a queue.
4. The worker threads will dequeue the queue and operate on the data.

Several notes and things to think about, though:

1. Take care of thread synchronization – specifically, you need to protect the queue.
2. Think if it matters which worker thread will get the data. If there are several chunks that need to be taken care of a specific worker thread, you’ll need to address this problem.
3. In some cases, if there is a very high load on the listener thread, the queue may become a bottleneck, or more precisely – the locking on the queue may become a bottleneck. In this case I would recommend moving into a model of N queues for N worker threads, and have the listener just pick one in a round-robin fashion. This will minimize the locks and actually since you’ll have one reader and one writer you can even get away without a lock (but this is out of scope for that answer).

Yet another option would be to use a thread pool. A thread pool is a pool of threads that are hibernating until they are needed. When the listener gets an incoming input it will allocate it to a free thread, or will enlarge the pool if needed; this way you don’t have a queue, and your threads are optimally used.