1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

Ziffern  4-Threads  1-Thread
29438      420        1155
29421      394        1151
29404      388        1150
29386      391        1149
....
998        29          39
981        32          39
964        31          38
946        30          37
929        26          36
912        25          36
895        25          37
878        26          35					

1:
2:
3:
4:
5:
6:

cts = new CancellationTokenSource(); // Damit kann der Berechnungsvorgang wieder abgebrochen werden
progressBar1.Maximum = 1;

var calculator = new Task(() => Calculate(_digits, _Numelems), cts.Token);
calculator.ContinueWith((x) => DisplayResult(x));
calculator.Start();					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:

private void Calculate(int digits, int numelems)
{
  for (int i = 0; i < digits; i++)
  {
    // In vier Teile teilen
    var pivot1 = (int)(numelems * 0.25);
    var pivot2 = (int)(numelems * 0.50);
    var pivot3 = (int)(numelems * 0.75);        
    // Die vier Teile anstoßen
    var Parts = new Task<ulong>[4];
    Parts[0] = Task.Factory.StartNew<ulong>(() => MultiplyCarryover(0, pivot1));
    Parts[1] = Task.Factory.StartNew<ulong>(() => MultiplyCarryover(pivot1 + 1, pivot2));
    Parts[2] = Task.Factory.StartNew<ulong>(() => MultiplyCarryover(pivot2 + 1, pivot3));
    Parts[3] = Task.Factory.StartNew<ulong>(() => MultiplyCarryover(pivot3 + 1, numelems));

    Task.WaitAll(Parts);
  
    // Der serielle Teil, der nicht parallelisiert werden kann
    AddCarry(pivot3, Parts[3].Result);
    AddCarry(pivot2, Parts[2].Result);
    AddCarry(pivot1, Parts[1].Result);

    result[i] = Parts[0].Result;

    // Fortschrittsbaleken aktualisieren, ggf. abbrechen
    if (i % 500 == 0)
    {
      this.Dispatcher.BeginInvoke(new Action(() => DisplayProgress(m * i + 5)));
      if (cts.IsCancellationRequested)
      {
        _digits = m * i + 5;
        return;
      }
    }
  }
}