Introductie

Situatie schets

Wanneer je bijvoorbeeld ieder uur enkele duizenden data files wilt importeren in een database, dan kan je dat op meerdere manieren doen. Iedere manier heeft zijn voordelen, maar ook zijn praktische problemen.

Het één voor één inlezen van de files levert de minste problemen op, maar dit is niet efficiënt en bovendien ongewenst in het geval je maar een beperkte tijd hebt voor de importtaak.

Het gelijktijdig starten van enkele duizenden threads levert hele andere problemen op. Je gaat je systeembronnen(CPU en geheugen) zwaar belasten, waardoor andere taken op de machine hinder kunnen ondervinden. Maar het grootste probleem zit hem echter in de ConnectionPool van de database. Het maximum aantal gelijktijdige connecties van de meeste database staat default op 100. Dit is natuurlijk aan te passen, maar ook hier ga je tegen resource problemen aan lopen. Het gevolg is een Exception dat je uit je ConnectionPool bent gelopen.

In de ideale situatie worden de files multi-threaded ingelezen, waarbij je aan kan geven hoeveel threads er gelijktijdig actief mogen zijn. Nu heb je je systeem bronnen onder controle en de database blijft zonder problemen ook voor andere processen benaderbaar.

Het .NET Framework 2.0 biedt enkele moegelijkheden, maar deze voldoen niet. De System.Threading.ThreadPool kan maar een maximum van 64 gelijktijdige threads aan en valt al meteen af. Een andere optie zou de System.Threading.Semaphore zijn, maar het nadeel hiervan is dat op voorhand alle processen al gestart worden. Dit duurt lang en vraagt ook al de nodige capaciteit van je systeembronnen.

Met de Managed Thead Queue zijn al deze problemen er niet meer en wordt Multi-Threading kinderspel. Zie onderstaand stukje code:

using System;
using System.Threading;
using _8bit.net.Threading;

namespace TestManagedThreadQueue
{
    class Program
    {
        class threaddata
        {
            public string name;
            public int number;
        }

        static void Main(string[] args)
        {
            int MaxConcurrentThreads = 8;
            using (ManagedThreadQueue myQueue = 
                new ManagedThreadQueue(MaxConcurrentThreads))
            {
                Console.WriteLine("Adding 500 items to the 
                    ManagedThreadQueue...");
                for (int x = 0; x < 500; x++)
                {
                    ParameterizedThreadStart t = 
                        new ParameterizedThreadStart(ThreadProc);
                    threaddata td = new threaddata();
                    td.number = x;
                    td.name = "name" + x;
                    myQueue.AddThread(t, td);
                    Thread.Sleep(30);
                }

                Console.WriteLine("Executing threads..");
                myQueue.WaitForAllThreadsToComplete();

                Console.WriteLine("Press  to exit...");
                Console.ReadLine();
            }

        }

        static void ThreadProc(object data)
        {
            threaddata info = (threaddata)data;
            
            Console.WriteLine("Number {0} started. Name {1}", 
                info.number, info.name  );
            Thread.Sleep(50);
            Console.WriteLine("Number {0} finished. Name {1}", 
                info.number, info.name);
        }
    }
}
                            

Kortweg wordt in dit voorbeeld een ManagedThreadQueue object, genaamd myQueue, aangemaakt met maximaal 8 gelijktijdige threads. Vervolgens wordt er 500 keer een ParameterizedThreadStart aangemaakt waaraan een bepaalde procedure wordt gebonden met de bijbehorende parameters. In dit geval ThreadProc. De functie ThreadProc is de procedure welke in iedere Thread uitgevoerd zal gaan worden. Tot slot wordt door middel van de methode WaitForAllThreadsToComplete gewacht tot alle aangemaakte threads uitgevoerd zijn.