MyThreadPool – Quick&Dirty

Hallo,

Ich war wiedermal auf Optimierungstour durch mein momentanes Projekt, und dort ist mir aufgefallen, dass das scheinbar asynchrone abarbeiten nur teils asynchron ist da ich vor gut 2-3 Monaten als ich das implementiert hatte folgendermaßen vorgegangen war:

Nachteile:

• Ein dauerhaft blockierender Thread (while(true)) startete seine Tochterthreads die, die eigentliche Arbeit erledigen, nachdem diese fertig waren, startete der Vaterthread wieder mehrere Tochterthreads, nur leider musste hier nun immer gewartet werden bis alle fertig sind, damit erneut weitere Threads gestartet werden konnte.

Abhilfe schafft die im Anhang befindliche Klasse, dieser übergibt man als Konstruktor eine Methode und eine Liste von Objekten die durchgegangen wird und abgearbeitet.

Vorteile:

• Kein blockierender Thread mehr, da jeder Thread der fertig ist auch sofort einen neuen Thread startet.
• Es laufen immer eine (fast) konstante Anzahl Threads gleichzeitig.

[codesyntax lang="csharp"]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace LWD.NET
{
    public class MyThreadPool
    {
        ParameterizedThreadStart m_ToDo;
        List<object[]> m_Threads = new List<object[]>();

        int m_index = 0;
        public MyThreadPool(IEnumerable<object> args, ParameterizedThreadStart start)
        {
            m_ToDo = start;

            //Creating a list for all threads, but dont start any thread!
            foreach (var obj in args)
            {
                try
                {
                    Thread t = new Thread(Execute);
                    t.IsBackground = true;
                    t.Name = obj.ToString();
                    t.SetApartmentState(ApartmentState.STA);
                    t.Priority = ThreadPriority.BelowNormal;
                    m_Threads.Add(new object[] { t, obj });
                }
                catch
                {

                }
            }

            for (int i = 0; i < Environment.ProcessorCount * 2; i++)
            {
                StartNext();
            }
        }

        private void StartNext()
        {
            lock (this)
            {
                if (m_index == m_Threads.Count)
                    return;
                var obj = m_Threads[m_index++];
                ((Thread)obj[0]).Start(obj[1]);
            }
        }

        private void Execute(object o)
        {
            try
            {
                m_ToDo(o);
            }
            catch
            {
            }
            finally
            {
                StartNext();
            }
        }
    }
}

[/codesyntax]