Ich hatte bereits über die Parallel Extensions für .NET berichtet, nun hatte ich ein wenig Zeit auf der langen Zugfahrt das ein oder andere auszuprobieren.

Das Paralellisieren von kompletten Funktionsblöcken lässt sich sehr einfach realisieren. Nehmen wir an, wir hätten 4 Methoden namens Warte(), Mal(), BinGleich(), Fertig(). Nun kann man diese 4 Methoden mit dem Parallel.Do Befehl entsprechend dem Framework übergeben und dieses sorgt dafür das die Methoden mit der Anzahl der zur Verfügung stehenden Prozessoren, bzw. Cores ausgeführt werden.

   1: Parallel.Do( 
   2:     () => Warte(),
   3:     () => Mal(),
   4:     () => BinGleich(),
   5:     () => Fertig() );

Dies ist ähnlich der OpenMP Pragma direktive die entsprechend Funktionen mit dem Pragma #section kennzeichnet.

Man benötigt nicht mehr den Umgang mit dem Threading Modell, sondern arbeitet mehr an der eigentlichen Problemlösung. Der Code den man bisher dafür geschrieben hat, könnte ungefähr so aussehen:

   1: using( ManualResetEvent warteEvent = new ManualResetEvent( false ) )
   2: using( ManualResetEvent malEvent = new ManualResetEvent( false ) )
   3: using( ManualResetEvent binGleichEvent = new ManualResetEvent( false ) )
   4: using( ManualResetEvent fertigEvent = new ManualResetEvent( false ) )
   5: {
   6:     ThreadPool.QueueUserWorkItem(delegate
   7:     {
   8:         Warte();
   9:         warteEvent.Set();
  10:     });
  11:     ThreadPool.QueueUserWorkItem(delegate
  12:     {
  13:         Mal();
  14:         malEvent.Set();
  15:     });
  16:     ThreadPool.QueueUserWorkItem(delegate
  17:     {
  18:         BinGleich();
  19:         binGleichEvent.Set();
  20:     });
  21:     ThreadPool.QueueUserWorkItem(delegate
  22:     {
  23:         Fertig();
  24:         fertigEvent.Set();
  25:     });
  26:     WaitHandle.WaitAll(new WaitHandle[]{warteEvent, malEvent, binGleichEvent, 
  27:         fertigEvent });
  28: }

Der Unterschied an Aufwand spricht für sich selbst.