Index: stable/HeuristicLab.Algorithms.Benchmarks/3.3/BenchmarkAlgorithm.cs
===================================================================
--- stable/HeuristicLab.Algorithms.Benchmarks/3.3/BenchmarkAlgorithm.cs	(revision 15278)
+++ stable/HeuristicLab.Algorithms.Benchmarks/3.3/BenchmarkAlgorithm.cs	(revision 15292)
@@ -302,25 +302,26 @@
     }
     public void Start() {
-      cancellationTokenSource = new CancellationTokenSource();
+      Start(CancellationToken.None);
+    }
+    public void Start(CancellationToken cancellationToken) {
+      cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
       OnStarted();
-      Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token);
-      task.ContinueWith(t => {
-        try {
-          t.Wait();
-        }
-        catch (AggregateException ex) {
-          try {
-            ex.Flatten().Handle(x => x is OperationCanceledException);
-          }
-          catch (AggregateException remaining) {
-            if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]);
-            else OnExceptionOccurred(remaining);
-          }
-        }
-
-        cancellationTokenSource.Dispose();
-        cancellationTokenSource = null;
-        OnStopped();
-      });
+
+      try {
+        Run(cancellationTokenSource.Token);
+      } catch (OperationCanceledException) {
+      } catch (AggregateException ae) {
+        OnExceptionOccurred(ae.InnerExceptions.SingleOrDefault() ?? ae);
+      } catch (Exception e) {
+        OnExceptionOccurred(e);
+      }
+
+      cancellationTokenSource.Dispose();
+      cancellationTokenSource = null;
+      OnStopped();
+    }
+    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
+    public async Task StartAsync(CancellationToken cancellationToken) {
+      await AsyncHelper.DoAsync(Start, cancellationToken);
     }
 
@@ -346,8 +347,6 @@
         Benchmark.TimeLimit = timelimit;
         Benchmark.Run(cancellationToken, results);
-      }
-      catch (OperationCanceledException) {
-      }
-      finally {
+      } catch (OperationCanceledException) {
+      } finally {
         timer.Elapsed -= new System.Timers.ElapsedEventHandler(timer_Elapsed);
         timer.Stop();
Index: stable/HeuristicLab.Algorithms.DataAnalysis.Views/3.4/CrossValidationView.cs
===================================================================
--- stable/HeuristicLab.Algorithms.DataAnalysis.Views/3.4/CrossValidationView.cs	(revision 15278)
+++ stable/HeuristicLab.Algorithms.DataAnalysis.Views/3.4/CrossValidationView.cs	(revision 15292)
@@ -223,5 +223,5 @@
 
     private void startButton_Click(object sender, EventArgs e) {
-      Content.Start();
+      Content.StartAsync();
     }
     private void pauseButton_Click(object sender, EventArgs e) {
Index: stable/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs
===================================================================
--- stable/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs	(revision 15278)
+++ stable/HeuristicLab.Algorithms.DataAnalysis/3.4/CrossValidation.cs	(revision 15292)
@@ -25,4 +25,5 @@
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using HeuristicLab.Collections;
 using HeuristicLab.Common;
@@ -42,4 +43,7 @@
     [Storable]
     private int seed;
+
+    private SemaphoreSlim availableWorkers; // limits the number of concurrent algorithm executions
+    private ManualResetEventSlim allAlgorithmsFinished; // this indicates that all started algorithms have been paused or stopped
 
     public CrossValidation()
@@ -269,4 +273,5 @@
 
     public void Prepare() {
+      if (startPending) return;
       if (ExecutionState == ExecutionState.Started)
         throw new InvalidOperationException(string.Format("Prepare not allowed in execution state \"{0}\".", ExecutionState));
@@ -283,11 +288,20 @@
     }
 
+    private bool startPending;
     public void Start() {
-      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
-        throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
-
-      seed = new FastRandom().NextInt();
-
-      if (Algorithm != null) {
+      Start(CancellationToken.None);
+    }
+    public void Start(CancellationToken cancellationToken) {
+      lock (locker) {
+        if (startPending) return;
+        startPending = true;
+      }
+
+      try {
+        if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
+          throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
+        seed = new FastRandom().NextInt();
+
+        if (Algorithm == null) return;
         //create cloned algorithms
         if (clonedAlgorithms.Count == 0) {
@@ -330,41 +344,47 @@
         }
 
-        //start prepared or paused cloned algorithms
-        int startedAlgorithms = 0;
-        foreach (IAlgorithm clonedAlgorithm in clonedAlgorithms) {
-          if (startedAlgorithms < NumberOfWorkers.Value) {
-            if (clonedAlgorithm.ExecutionState == ExecutionState.Prepared ||
-                clonedAlgorithm.ExecutionState == ExecutionState.Paused) {
-
-              // start and wait until the alg is started 
-              using (var signal = new ManualResetEvent(false)) {
-                EventHandler signalSetter = (sender, args) => { signal.Set(); };
-                clonedAlgorithm.Started += signalSetter;
-                clonedAlgorithm.Start();
-                signal.WaitOne();
-                clonedAlgorithm.Started -= signalSetter;
-
-                startedAlgorithms++;
-              }
-            }
+        OnStarted();
+      } finally {
+        if (startPending) startPending = false;
+      }
+
+      availableWorkers = new SemaphoreSlim(NumberOfWorkers.Value, NumberOfWorkers.Value);
+      allAlgorithmsFinished = new ManualResetEventSlim(false);
+
+      //start prepared or paused cloned algorithms
+      foreach (IAlgorithm clonedAlgorithm in clonedAlgorithms) {
+        if (pausePending || stopPending || ExecutionState != ExecutionState.Started) break;
+        if (clonedAlgorithm.ExecutionState == ExecutionState.Prepared ||
+            clonedAlgorithm.ExecutionState == ExecutionState.Paused) {
+          availableWorkers.Wait();
+          lock (locker) {
+            if (pausePending || stopPending || ExecutionState != ExecutionState.Started) break;
+            clonedAlgorithm.StartAsync(cancellationToken);
           }
         }
-        OnStarted();
-      }
+      }
+
+      allAlgorithmsFinished.Wait();
+    }
+
+    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
+    public async Task StartAsync(CancellationToken cancellationToken) {
+      await AsyncHelper.DoAsync(Start, cancellationToken);
     }
 
     private bool pausePending;
     public void Pause() {
+      if (startPending) return;
       if (ExecutionState != ExecutionState.Started)
         throw new InvalidOperationException(string.Format("Pause not allowed in execution state \"{0}\".", ExecutionState));
       if (!pausePending) {
         pausePending = true;
-        PauseAllClonedAlgorithms();
-      }
-    }
-    private void PauseAllClonedAlgorithms() {
-      foreach (IAlgorithm clonedAlgorithm in clonedAlgorithms) {
-        if (clonedAlgorithm.ExecutionState == ExecutionState.Started)
-          clonedAlgorithm.Pause();
+        lock (locker) {
+          var toPause = clonedAlgorithms.Where(x => x.ExecutionState == ExecutionState.Started).ToList();
+          foreach (var optimizer in toPause) {
+            // a race-condition may occur when the optimizer has changed the state by itself in the meantime
+            try { optimizer.Pause(); } catch (InvalidOperationException) { }
+          }
+        }
       }
     }
@@ -372,4 +392,5 @@
     private bool stopPending;
     public void Stop() {
+      if (startPending) return;
       if ((ExecutionState != ExecutionState.Started) && (ExecutionState != ExecutionState.Paused))
         throw new InvalidOperationException(string.Format("Stop not allowed in execution state \"{0}\".",
@@ -377,12 +398,11 @@
       if (!stopPending) {
         stopPending = true;
-        StopAllClonedAlgorithms();
-      }
-    }
-    private void StopAllClonedAlgorithms() {
-      foreach (IAlgorithm clonedAlgorithm in clonedAlgorithms) {
-        if (clonedAlgorithm.ExecutionState == ExecutionState.Started ||
-            clonedAlgorithm.ExecutionState == ExecutionState.Paused)
-          clonedAlgorithm.Stop();
+        lock (locker) {
+          var toStop = clonedAlgorithms.Where(x => x.ExecutionState == ExecutionState.Started || x.ExecutionState == ExecutionState.Paused).ToList();
+          foreach (var optimizer in toStop) {
+            // a race-condition may occur when the optimizer has changed the state by itself in the meantime
+            try { optimizer.Stop(); } catch (InvalidOperationException) { }
+          }
+        }
       }
     }
@@ -685,4 +705,5 @@
     }
     private void ClonedAlgorithm_ExceptionOccurred(object sender, EventArgs<Exception> e) {
+      Pause();
       OnExceptionOccurred(e.Value);
     }
@@ -703,6 +724,9 @@
     private void ClonedAlgorithm_Paused(object sender, EventArgs e) {
       lock (locker) {
-        if (pausePending && clonedAlgorithms.All(alg => alg.ExecutionState != ExecutionState.Started))
+        availableWorkers.Release();
+        if (clonedAlgorithms.All(alg => alg.ExecutionState != ExecutionState.Started)) {
           OnPaused();
+          allAlgorithmsFinished.Set();
+        }
       }
     }
@@ -710,16 +734,13 @@
     private void ClonedAlgorithm_Stopped(object sender, EventArgs e) {
       lock (locker) {
-        if (!stopPending && ExecutionState == ExecutionState.Started) {
-          IAlgorithm preparedAlgorithm = clonedAlgorithms.FirstOrDefault(alg => alg.ExecutionState == ExecutionState.Prepared ||
-                                                                                alg.ExecutionState == ExecutionState.Paused);
-          if (preparedAlgorithm != null) preparedAlgorithm.Start();
-        }
-        if (ExecutionState != ExecutionState.Stopped) {
-          if (clonedAlgorithms.All(alg => alg.ExecutionState == ExecutionState.Stopped))
-            OnStopped();
-          else if (stopPending &&
-                   clonedAlgorithms.All(
-                     alg => alg.ExecutionState == ExecutionState.Prepared || alg.ExecutionState == ExecutionState.Stopped))
-            OnStopped();
+        // if the algorithm was in paused state, its worker has already been released
+        if (availableWorkers.CurrentCount < NumberOfWorkers.Value)
+          availableWorkers.Release();
+        if (clonedAlgorithms.All(alg => alg.ExecutionState == ExecutionState.Stopped)) {
+          OnStopped();
+          allAlgorithmsFinished.Set();
+        } else if (stopPending && clonedAlgorithms.All(alg => alg.ExecutionState == ExecutionState.Prepared || alg.ExecutionState == ExecutionState.Stopped)) {
+          OnStopped();
+          allAlgorithmsFinished.Set();
         }
       }
@@ -748,4 +769,5 @@
     public event EventHandler Started;
     private void OnStarted() {
+      startPending = false;
       ExecutionState = ExecutionState.Started;
       EventHandler handler = Started;
Index: stable/HeuristicLab.Algorithms.DataAnalysis/3.4/FixedDataAnalysisAlgorithm.cs
===================================================================
--- stable/HeuristicLab.Algorithms.DataAnalysis/3.4/FixedDataAnalysisAlgorithm.cs	(revision 15278)
+++ stable/HeuristicLab.Algorithms.DataAnalysis/3.4/FixedDataAnalysisAlgorithm.cs	(revision 15292)
@@ -21,4 +21,6 @@
 
 using System;
+using System.Linq;
+using System.Threading;
 using HeuristicLab.Common;
 using HeuristicLab.Optimization;
Index: stable/HeuristicLab.Clients.Hive/3.3/Tasks/EngineTask.cs
===================================================================
--- stable/HeuristicLab.Clients.Hive/3.3/Tasks/EngineTask.cs	(revision 15278)
+++ stable/HeuristicLab.Clients.Hive/3.3/Tasks/EngineTask.cs	(revision 15292)
@@ -81,5 +81,5 @@
     public override void Start() {
       Item.Prepare(initialOperation);
-      Item.Start();
+      Item.StartAsync();
     }
 
Index: stable/HeuristicLab.Clients.Hive/3.3/Tasks/OptimizerTask.cs
===================================================================
--- stable/HeuristicLab.Clients.Hive/3.3/Tasks/OptimizerTask.cs	(revision 15278)
+++ stable/HeuristicLab.Clients.Hive/3.3/Tasks/OptimizerTask.cs	(revision 15292)
@@ -101,5 +101,5 @@
         OnTaskStopped();
       } else {
-        Item.Start();
+        Item.StartAsync();
       }
     }
Index: stable/HeuristicLab.Clients.OKB.Views/3.3/RunCreation/Views/OKBAlgorithmView.cs
===================================================================
--- stable/HeuristicLab.Clients.OKB.Views/3.3/RunCreation/Views/OKBAlgorithmView.cs	(revision 15278)
+++ stable/HeuristicLab.Clients.OKB.Views/3.3/RunCreation/Views/OKBAlgorithmView.cs	(revision 15292)
@@ -325,5 +325,5 @@
     }
     private void startButton_Click(object sender, EventArgs e) {
-      Content.Start();
+      Content.StartAsync();
     }
     private void pauseButton_Click(object sender, EventArgs e) {
Index: stable/HeuristicLab.Clients.OKB/3.3/RunCreation/OKBAlgorithm.cs
===================================================================
--- stable/HeuristicLab.Clients.OKB/3.3/RunCreation/OKBAlgorithm.cs	(revision 15278)
+++ stable/HeuristicLab.Clients.OKB/3.3/RunCreation/OKBAlgorithm.cs	(revision 15292)
@@ -20,4 +20,6 @@
 #endregion
 
+using System.Threading;
+using System.Threading.Tasks;
 using HeuristicLab.Clients.Access;
 using HeuristicLab.Collections;
@@ -67,6 +69,5 @@
             try {
               algorithm.Problem = problem;
-            }
-            catch (ArgumentException) {
+            } catch (ArgumentException) {
               algorithm.Problem = null;
             }
@@ -250,9 +251,16 @@
     }
     public void Start() {
+      Start(CancellationToken.None);
+    }
+    public void Start(CancellationToken cancellationToken) {
       CheckUserPermissions();
       if (!ClientInformation.Instance.ClientExists && storeRunsAutomatically) {
         throw new MissingClientRegistrationException();
       }
-      Algorithm.Start();
+      Algorithm.Start(cancellationToken);
+    }
+    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
+    public async Task StartAsync(CancellationToken cancellationToken) {
+      await AsyncHelper.DoAsync(Start, cancellationToken);
     }
     public void Pause() {
Index: stable/HeuristicLab.Common/3.3/AsyncHelper.cs
===================================================================
--- stable/HeuristicLab.Common/3.3/AsyncHelper.cs	(revision 15292)
+++ stable/HeuristicLab.Common/3.3/AsyncHelper.cs	(revision 15292)
@@ -0,0 +1,45 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2017 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Common {
+  public static class AsyncHelper {
+    public static async Task DoAsync(Action<CancellationToken> startAction, CancellationToken cancellationToken) {
+      try {
+        await Task.Factory.StartNew(
+          ct => startAction((CancellationToken)ct),
+          cancellationToken,
+          cancellationToken,
+          TaskCreationOptions.DenyChildAttach | TaskCreationOptions.LongRunning,
+          TaskScheduler.Default);
+      } catch (OperationCanceledException) {
+      } catch (AggregateException ae) {
+        var e = ae.InnerExceptions.SingleOrDefault() ?? ae;
+        ExceptionDispatchInfo.Capture(e).Throw();
+      }
+    }
+  }
+}
Index: stable/HeuristicLab.Common/3.3/HeuristicLab.Common-3.3.csproj
===================================================================
--- stable/HeuristicLab.Common/3.3/HeuristicLab.Common-3.3.csproj	(revision 15278)
+++ stable/HeuristicLab.Common/3.3/HeuristicLab.Common-3.3.csproj	(revision 15292)
@@ -123,4 +123,5 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AsyncHelper.cs" />
     <Compile Include="CancelEventArgs.cs" />
     <None Include="Plugin.cs.frame" />
Index: stable/HeuristicLab.Core/3.3/Engine.cs
===================================================================
--- stable/HeuristicLab.Core/3.3/Engine.cs	(revision 15278)
+++ stable/HeuristicLab.Core/3.3/Engine.cs	(revision 15292)
@@ -22,6 +22,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
-using System.Threading.Tasks;
 using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -82,28 +82,23 @@
     }
 
-    public override void Start() {
-      base.Start();
-      cancellationTokenSource = new CancellationTokenSource();
+    public override void Start(CancellationToken cancellationToken) {
+      base.Start(cancellationToken);
+      cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
       stopPending = false;
-      Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token);
-      task.ContinueWith(t => {
-        try {
-          t.Wait();
-        }
-        catch (AggregateException ex) {
-          try {
-            ex.Flatten().Handle(x => x is OperationCanceledException);
-          }
-          catch (AggregateException remaining) {
-            if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]);
-            else OnExceptionOccurred(remaining);
-          }
-        }
-        cancellationTokenSource.Dispose();
-        cancellationTokenSource = null;
-        if (stopPending) executionStack.Clear();
-        if (executionStack.Count == 0) OnStopped();
-        else OnPaused();
-      });
+
+      try {
+        Run((object)cancellationTokenSource.Token);
+      } catch (OperationCanceledException) {
+      } catch (AggregateException ae) {
+        OnExceptionOccurred(ae.InnerExceptions.SingleOrDefault() ?? ae);
+      } catch (Exception e) {
+        OnExceptionOccurred(e);
+      }
+
+      cancellationTokenSource.Dispose();
+      cancellationTokenSource = null;
+      if (stopPending) executionStack.Clear();
+      if (executionStack.Count == 0) OnStopped();
+      else OnPaused();
     }
     protected override void OnStarted() {
@@ -152,6 +147,5 @@
       try {
         Run(cancellationToken);
-      }
-      finally {
+      } finally {
         timer.Elapsed -= new System.Timers.ElapsedEventHandler(timer_Elapsed);
         timer.Stop();
Index: stable/HeuristicLab.Core/3.3/Executable.cs
===================================================================
--- stable/HeuristicLab.Core/3.3/Executable.cs	(revision 15278)
+++ stable/HeuristicLab.Core/3.3/Executable.cs	(revision 15292)
@@ -22,4 +22,6 @@
 using System;
 using System.Drawing;
+using System.Threading;
+using System.Threading.Tasks;
 using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -83,6 +85,13 @@
     }
     public virtual void Start() {
+      Start(CancellationToken.None);
+    }
+    public virtual void Start(CancellationToken cancellationToken) {
       if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
         throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
+    }
+    public virtual async Task StartAsync() { await StartAsync(CancellationToken.None); }
+    public virtual async Task StartAsync(CancellationToken cancellationToken) {
+      await AsyncHelper.DoAsync(Start, cancellationToken);
     }
     public virtual void Pause() {
Index: stable/HeuristicLab.Core/3.3/Interfaces/IExecutable.cs
===================================================================
--- stable/HeuristicLab.Core/3.3/Interfaces/IExecutable.cs	(revision 15278)
+++ stable/HeuristicLab.Core/3.3/Interfaces/IExecutable.cs	(revision 15292)
@@ -21,4 +21,6 @@
 
 using System;
+using System.Threading;
+using System.Threading.Tasks;
 using HeuristicLab.Common;
 
@@ -30,4 +32,7 @@
     void Prepare();
     void Start();
+    void Start(CancellationToken cancellationToken);
+    Task StartAsync();
+    Task StartAsync(CancellationToken cancellationToken);
     void Pause();
     void Stop();
Index: stable/HeuristicLab.DebugEngine/3.3/DebugEngine.cs
===================================================================
--- stable/HeuristicLab.DebugEngine/3.3/DebugEngine.cs	(revision 15278)
+++ stable/HeuristicLab.DebugEngine/3.3/DebugEngine.cs	(revision 15292)
@@ -23,5 +23,4 @@
 using System.Linq;
 using System.Threading;
-using System.Threading.Tasks;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -161,6 +160,5 @@
         while (skipStackOperations && !(CurrentOperation is IAtomicOperation) && CanContinue)
           ProcessNextOperation(true, cancellationTokenSource.Token);
-      }
-      catch (Exception ex) {
+      } catch (Exception ex) {
         OnExceptionOccurred(ex);
       }
@@ -174,31 +172,24 @@
     }
 
-    public override void Start() {
-      base.Start();
-      cancellationTokenSource = new CancellationTokenSource();
+    public override void Start(CancellationToken cancellationToken) {
+      base.Start(cancellationToken);
+      cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
       stopPending = false;
-      Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token);
-      task.ContinueWith(t => {
-        try {
-          t.Wait();
-        }
-        catch (AggregateException ex) {
-          try {
-            ex.Flatten().Handle(x => x is OperationCanceledException);
-          }
-          catch (AggregateException remaining) {
-            if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]);
-            else OnExceptionOccurred(remaining);
-          }
-        }
-        cancellationTokenSource.Dispose();
-        cancellationTokenSource = null;
-
-        if (stopPending) ExecutionStack.Clear();
-        if (stopPending || !CanContinue) OnStopped();
-        else OnPaused();
-      });
-    }
-
+
+      try {
+        Run(cancellationTokenSource.Token);
+      } catch (OperationCanceledException) {
+      } catch (AggregateException ae) {
+        OnExceptionOccurred(ae.InnerExceptions.SingleOrDefault() ?? ae);
+      } catch (Exception e) {
+        OnExceptionOccurred(e);
+      }
+
+      cancellationTokenSource.Dispose();
+      cancellationTokenSource = null;
+      if (stopPending) ExecutionStack.Clear();
+      if (stopPending || !CanContinue) OnStopped();
+      else OnPaused();
+    }
     protected override void OnStarted() {
       Log.LogMessage("Engine started");
@@ -250,6 +241,5 @@
           ProcessNextOperation(false, cancellationToken);
         cancellationToken.ThrowIfCancellationRequested();
-      }
-      finally {
+      } finally {
         timer.Stop();
         ExecutionTime += DateTime.UtcNow - lastUpdateTime;
@@ -317,6 +307,5 @@
           }
           CurrentOperation = null;
-        }
-        catch (Exception ex) {
+        } catch (Exception ex) {
           if (ex is OperationCanceledException) throw ex;
           else throw new OperatorExecutionException(operation.Operator, ex);
Index: stable/HeuristicLab.Optimization.Views/3.3/IOptimizerView.cs
===================================================================
--- stable/HeuristicLab.Optimization.Views/3.3/IOptimizerView.cs	(revision 15278)
+++ stable/HeuristicLab.Optimization.Views/3.3/IOptimizerView.cs	(revision 15292)
@@ -137,5 +137,5 @@
     #region Control events
     protected virtual void startButton_Click(object sender, EventArgs e) {
-      Content.Start();
+      Content.StartAsync();
     }
     protected virtual void pauseButton_Click(object sender, EventArgs e) {
Index: stable/HeuristicLab.Optimization/3.3/Algorithms/Algorithm.cs
===================================================================
--- stable/HeuristicLab.Optimization/3.3/Algorithms/Algorithm.cs	(revision 15278)
+++ stable/HeuristicLab.Optimization/3.3/Algorithms/Algorithm.cs	(revision 15292)
@@ -24,4 +24,6 @@
 using System.Drawing;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using HeuristicLab.Collections;
 using HeuristicLab.Common;
@@ -203,6 +205,13 @@
     }
     public virtual void Start() {
+      Start(CancellationToken.None);
+    }
+    public virtual void Start(CancellationToken cancellationToken) {
       if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
         throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
+    }
+    public virtual async Task StartAsync() { await StartAsync(CancellationToken.None); }
+    public virtual async Task StartAsync(CancellationToken cancellationToken) {
+      await AsyncHelper.DoAsync(Start, cancellationToken);
     }
     public virtual void Pause() {
Index: stable/HeuristicLab.Optimization/3.3/Algorithms/BasicAlgorithm.cs
===================================================================
--- stable/HeuristicLab.Optimization/3.3/Algorithms/BasicAlgorithm.cs	(revision 15278)
+++ stable/HeuristicLab.Optimization/3.3/Algorithms/BasicAlgorithm.cs	(revision 15292)
@@ -21,6 +21,6 @@
 
 using System;
+using System.Linq;
 using System.Threading;
-using System.Threading.Tasks;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -71,29 +71,23 @@
     }
 
-    public override void Start() {
-      base.Start();
-      CancellationTokenSource = new CancellationTokenSource();
+    public override void Start(CancellationToken cancellationToken) {
+      base.Start(cancellationToken);
+      CancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
       pausePending = false;
       OnStarted();
 
-      Task task = Task.Factory.StartNew(Run, CancellationTokenSource.Token, CancellationTokenSource.Token);
-      task.ContinueWith(t => {
-        try {
-          t.Wait();
-        }
-        catch (AggregateException ex) {
-          try {
-            ex.Flatten().Handle(x => x is OperationCanceledException);
-          }
-          catch (AggregateException remaining) {
-            if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]);
-            else OnExceptionOccurred(remaining);
-          }
-        }
-        CancellationTokenSource.Dispose();
-        CancellationTokenSource = null;
-        if (pausePending) OnPaused();
-        else OnStopped();
-      });
+      try {
+        Run((object)cancellationTokenSource.Token);
+      } catch (OperationCanceledException) {
+      } catch (AggregateException ae) {
+        OnExceptionOccurred(ae.InnerExceptions.SingleOrDefault() ?? ae);
+      } catch (Exception e) {
+        OnExceptionOccurred(e);
+      }
+
+      CancellationTokenSource.Dispose();
+      CancellationTokenSource = null;
+      if (pausePending) OnPaused();
+      else OnStopped();
     }
 
Index: stable/HeuristicLab.Optimization/3.3/Algorithms/EngineAlgorithm.cs
===================================================================
--- stable/HeuristicLab.Optimization/3.3/Algorithms/EngineAlgorithm.cs	(revision 15278)
+++ stable/HeuristicLab.Optimization/3.3/Algorithms/EngineAlgorithm.cs	(revision 15292)
@@ -168,7 +168,7 @@
       }
     }
-    public override void Start() {
-      base.Start();
-      if (engine != null) engine.Start();
+    public override void Start(System.Threading.CancellationToken cancellationToken) {
+      base.Start(cancellationToken);
+      if (engine != null) engine.Start(cancellationToken);
     }
     public override void Pause() {
Index: stable/HeuristicLab.Optimization/3.3/MetaOptimizers/BatchRun.cs
===================================================================
--- stable/HeuristicLab.Optimization/3.3/MetaOptimizers/BatchRun.cs	(revision 15278)
+++ stable/HeuristicLab.Optimization/3.3/MetaOptimizers/BatchRun.cs	(revision 15292)
@@ -23,4 +23,6 @@
 using System.Collections.Generic;
 using System.Drawing;
+using System.Threading;
+using System.Threading.Tasks;
 using HeuristicLab.Collections;
 using HeuristicLab.Common;
@@ -237,6 +239,5 @@
         batchRunAction = BatchRunAction.Prepare;
         // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-        try { Optimizer.Prepare(clearRuns); }
-        catch (InvalidOperationException) { }
+        try { Optimizer.Prepare(clearRuns); } catch (InvalidOperationException) { }
       } else {
         ExecutionState = ExecutionState.Stopped;
@@ -244,4 +245,7 @@
     }
     public void Start() {
+      Start(CancellationToken.None);
+    }
+    public void Start(CancellationToken cancellationToken) {
       if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
         throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
@@ -249,7 +253,14 @@
       batchRunAction = BatchRunAction.Start;
       if (Optimizer.ExecutionState == ExecutionState.Stopped) Optimizer.Prepare();
-      // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-      try { Optimizer.Start(); }
-      catch (InvalidOperationException) { }
+      for (int i = repetitionsCounter; i < repetitions; i++) {
+        // a race-condition may occur when the optimizer has changed the state by itself in the meantime
+        try { Optimizer.Start(cancellationToken); } catch (InvalidOperationException) { }
+        if (ExecutionState == ExecutionState.Paused || ExecutionState == ExecutionState.Stopped) break;
+        Optimizer.Prepare();
+      }
+    }
+    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
+    public async Task StartAsync(CancellationToken cancellationToken) {
+      await AsyncHelper.DoAsync(Start, cancellationToken);
     }
     public void Pause() {
@@ -260,6 +271,5 @@
       if (Optimizer.ExecutionState != ExecutionState.Started) return;
       // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-      try { Optimizer.Pause(); }
-      catch (InvalidOperationException) { }
+      try { Optimizer.Pause(); } catch (InvalidOperationException) { }
     }
     public void Stop() {
@@ -273,6 +283,5 @@
       }
       // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-      try { Optimizer.Stop(); }
-      catch (InvalidOperationException) { }
+      try { Optimizer.Stop(); } catch (InvalidOperationException) { }
     }
 
@@ -395,8 +404,6 @@
       else if (repetitionsCounter >= repetitions) OnStopped();
       else if (batchRunAction == BatchRunAction.Pause) OnPaused();
-      else if (batchRunAction == BatchRunAction.Start) {
-        Optimizer.Prepare();
-        Optimizer.Start();
-      } else if (executionState == ExecutionState.Started) {
+      else if (batchRunAction == BatchRunAction.Start) return;
+      else if (executionState == ExecutionState.Started) {
         // if the batch run hasn't been started but the inner optimizer was run then pause
         OnPaused();
Index: stable/HeuristicLab.Optimization/3.3/MetaOptimizers/Experiment.cs
===================================================================
--- stable/HeuristicLab.Optimization/3.3/MetaOptimizers/Experiment.cs	(revision 15278)
+++ stable/HeuristicLab.Optimization/3.3/MetaOptimizers/Experiment.cs	(revision 15292)
@@ -25,4 +25,5 @@
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using HeuristicLab.Collections;
 using HeuristicLab.Common;
@@ -181,9 +182,11 @@
       foreach (IOptimizer optimizer in Optimizers.Where(x => x.ExecutionState != ExecutionState.Started)) {
         // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-        try { optimizer.Prepare(clearRuns); }
-        catch (InvalidOperationException) { }
+        try { optimizer.Prepare(clearRuns); } catch (InvalidOperationException) { }
       }
     }
     public void Start() {
+      Start(CancellationToken.None);
+    }
+    public void Start(CancellationToken cancellationToken) {
       if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused))
         throw new InvalidOperationException(string.Format("Start not allowed in execution state \"{0}\".", ExecutionState));
@@ -192,10 +195,14 @@
       experimentStarted = true;
       experimentStopped = false;
-      IOptimizer optimizer = Optimizers.FirstOrDefault(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused));
-      if (optimizer != null) {
+      IOptimizer optimizer;
+      while ((optimizer = Optimizers.FirstOrDefault(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) != null) {
         // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-        try { optimizer.Start(); }
-        catch (InvalidOperationException) { }
-      }
+        try { optimizer.Start(cancellationToken); } catch (InvalidOperationException) { }
+        if (ExecutionState == ExecutionState.Paused || ExecutionState == ExecutionState.Stopped) break;
+      }
+    }
+    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
+    public async Task StartAsync(CancellationToken cancellationToken) {
+      await AsyncHelper.DoAsync(Start, cancellationToken);
     }
     public void Pause() {
@@ -208,6 +215,5 @@
       foreach (IOptimizer optimizer in Optimizers.Where(x => x.ExecutionState == ExecutionState.Started)) {
         // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-        try { optimizer.Pause(); }
-        catch (InvalidOperationException) { }
+        try { optimizer.Pause(); } catch (InvalidOperationException) { }
       }
     }
@@ -222,6 +228,5 @@
         foreach (var optimizer in Optimizers.Where(x => (x.ExecutionState == ExecutionState.Started) || (x.ExecutionState == ExecutionState.Paused))) {
           // a race-condition may occur when the optimizer has changed the state by itself in the meantime
-          try { optimizer.Stop(); }
-          catch (InvalidOperationException) { }
+          try { optimizer.Stop(); } catch (InvalidOperationException) { }
         }
       } else {
@@ -357,6 +362,5 @@
       try {
         ExecutionTime = Optimizers.Aggregate(TimeSpan.Zero, (t, o) => t + o.ExecutionTime);
-      }
-      finally {
+      } finally {
         Monitor.Exit(locker);
       }
@@ -379,7 +383,6 @@
           if (Optimizers.All(x => (x.ExecutionState == ExecutionState.Stopped) || (x.ExecutionState == ExecutionState.Prepared))) OnStopped();
         } else {
-          if (experimentStarted && Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) {
-            Optimizers.First(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused)).Start();
-          } else if (Optimizers.All(x => x.ExecutionState == ExecutionState.Stopped)) OnStopped();
+          if (experimentStarted && Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused))) return;
+          else if (Optimizers.All(x => x.ExecutionState == ExecutionState.Stopped)) OnStopped();
           else if (Optimizers.Any(x => (x.ExecutionState == ExecutionState.Prepared) || (x.ExecutionState == ExecutionState.Paused)) && Optimizers.All(o => o.ExecutionState != ExecutionState.Started)) OnPaused();
         }
Index: stable/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs
===================================================================
--- stable/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs	(revision 15278)
+++ stable/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs	(revision 15292)
@@ -25,4 +25,5 @@
 using System.Drawing;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using HeuristicLab.Collections;
@@ -238,5 +239,12 @@
     }
     public void Start() {
-      Algorithm.Start();
+      Start(CancellationToken.None);
+    }
+    public void Start(CancellationToken cancellationToken) {
+      Algorithm.Start(cancellationToken);
+    }
+    public async Task StartAsync() { await StartAsync(CancellationToken.None); }
+    public async Task StartAsync(CancellationToken cancellationToken) {
+      await AsyncHelper.DoAsync(Start, cancellationToken);
     }
     public void Pause() {
Index: stable/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs
===================================================================
--- stable/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs	(revision 15278)
+++ stable/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs	(revision 15292)
@@ -22,4 +22,5 @@
 using System;
 using System.Linq;
+using System.Threading;
 using HeuristicLab.Analysis;
 using HeuristicLab.Common;
@@ -338,5 +339,5 @@
     }
 
-    public override void Start() {
+    public override void Start(CancellationToken cancellationToken) {
       if (ExecutionState == ExecutionState.Prepared) {
         int dim = Problem.Weights.Rows;
@@ -350,5 +351,5 @@
         GlobalScope.Variables.Add(new Variable("MoveQualityMatrix", new DoubleMatrix(dim, dim)));
       }
-      base.Start();
+      base.Start(cancellationToken);
     }
 
Index: stable/HeuristicLab.Tests/HeuristicLab-3.3/AlgorithmExtensions.cs
===================================================================
--- stable/HeuristicLab.Tests/HeuristicLab-3.3/AlgorithmExtensions.cs	(revision 15278)
+++ 	(revision )
@@ -1,86 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Threading;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Tests {
-  public static class AlgorithmExtensions {
-    public static void StartSync(this IExecutable executable, CancellationToken cancellationToken) {
-      var executor = new AlgorithmExecutor(executable, cancellationToken);
-      executor.StartSync();
-    }
-  }
-
-  /// <summary>
-  /// Can execute an algorithm synchronously
-  /// </summary>
-  internal class AlgorithmExecutor {
-    private IExecutable executable;
-    private AutoResetEvent waitHandle = new AutoResetEvent(false);
-    private CancellationToken cancellationToken;
-    private Exception occuredException;
-
-    public AlgorithmExecutor(IExecutable executable, CancellationToken cancellationToken) {
-      this.executable = executable;
-      this.cancellationToken = cancellationToken;
-      this.occuredException = null;
-    }
-
-    public void StartSync() {
-      executable.Stopped += new EventHandler(executable_Stopped);
-      executable.Paused += new EventHandler(executable_Paused);
-      executable.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(executable_ExceptionOccurred);
-
-      using (CancellationTokenRegistration registration = cancellationToken.Register(new Action(cancellationToken_Canceled))) {
-        executable.Start();
-        waitHandle.WaitOne(-1, false);
-        waitHandle.Dispose();
-      }
-
-      executable.Stopped -= new EventHandler(executable_Stopped);
-      executable.Paused -= new EventHandler(executable_Paused);
-      if (executable.ExecutionState == ExecutionState.Started) {
-        executable.Pause();
-      }
-      cancellationToken.ThrowIfCancellationRequested();
-      if (occuredException != null) throw occuredException;
-    }
-
-    private void executable_Paused(object sender, EventArgs e) {
-      waitHandle.Set();
-    }
-
-    private void executable_Stopped(object sender, EventArgs e) {
-      waitHandle.Set();
-    }
-
-    private void executable_ExceptionOccurred(object sender, EventArgs<Exception> e) {
-      occuredException = e.Value; // after an exception occured the executable pauses
-    }
-
-    private void cancellationToken_Canceled() {
-      waitHandle.Set();
-    }
-  }
-}
Index: stable/HeuristicLab.Tests/HeuristicLab-3.3/CollectObjectGraphTest.cs
===================================================================
--- stable/HeuristicLab.Tests/HeuristicLab-3.3/CollectObjectGraphTest.cs	(revision 15278)
+++ stable/HeuristicLab.Tests/HeuristicLab-3.3/CollectObjectGraphTest.cs	(revision 15292)
@@ -24,5 +24,4 @@
 using System.Diagnostics;
 using System.Linq;
-using System.Threading;
 using System.Threading.Tasks;
 using HeuristicLab.Algorithms.GeneticAlgorithm;
@@ -125,6 +124,5 @@
         algs.Add(ga);
 
-        var cancellationTokenSource = new CancellationTokenSource();
-        ga.StartSync(cancellationTokenSource.Token);
+        ga.Start();
         sw.Stop();
         TestContext.WriteLine("{0}: {1} ", i, sw.Elapsed);
@@ -157,5 +155,5 @@
           var sw = new Stopwatch();
           sw.Start();
-          ga.StartSync(new CancellationToken());
+          ga.Start();
           sw.Stop();
           Console.WriteLine("{0}; Objects after execution: {1}", ga.Name, ga.GetObjectGraphObjects().Count());
Index: stable/HeuristicLab.Tests/HeuristicLab-3.3/GeneticAlgorithmTest.cs
===================================================================
--- stable/HeuristicLab.Tests/HeuristicLab-3.3/GeneticAlgorithmTest.cs	(revision 15278)
+++ stable/HeuristicLab.Tests/HeuristicLab-3.3/GeneticAlgorithmTest.cs	(revision 15292)
@@ -21,5 +21,4 @@
 
 using System;
-using System.Threading;
 using HeuristicLab.Algorithms.GeneticAlgorithm;
 using HeuristicLab.Common;
@@ -39,5 +38,4 @@
     }
 
-    private EventWaitHandle trigger = new AutoResetEvent(false);
     private Exception ex;
 
@@ -49,5 +47,4 @@
       GeneticAlgorithm ga = (GeneticAlgorithm)XmlParser.Deserialize(@"Test Resources\GA_TSP.hl");
       ga.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(ga_ExceptionOccurred);
-      ga.Stopped += new EventHandler(ga_Stopped);
       ga.SetSeedRandomly.Value = false;
       ga.Seed.Value = 0;
@@ -55,5 +52,4 @@
       ga.Prepare();
       ga.Start();
-      trigger.WaitOne();
       if (ex != null) throw ex;
 
@@ -80,8 +76,4 @@
       ex = e.Value;
     }
-
-    private void ga_Stopped(object sender, EventArgs e) {
-      trigger.Set();
-    }
   }
 }
Index: stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/SamplesUtils.cs
===================================================================
--- stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/SamplesUtils.cs	(revision 15278)
+++ stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/SamplesUtils.cs	(revision 15292)
@@ -1,5 +1,4 @@
 using System;
 using System.Linq;
-using System.Threading;
 using HeuristicLab.Algorithms.ALPS;
 using HeuristicLab.Algorithms.EvolutionStrategy;
@@ -18,13 +17,9 @@
 
     public static void RunAlgorithm(IAlgorithm a) {
-      var trigger = new EventWaitHandle(false, EventResetMode.ManualReset);
       Exception ex = null;
-      a.Stopped += (src, e) => { trigger.Set(); };
-      a.ExceptionOccurred += (src, e) => { ex = e.Value; trigger.Set(); };
+      a.ExceptionOccurred += (sender, e) => { ex = e.Value; };
       a.Prepare();
       a.Start();
-      trigger.WaitOne();
-
-      Assert.AreEqual(ex, null);
+      Assert.IsNull(ex);
     }
 
Index: stable/HeuristicLab.Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/GaussianProcessRegressionTest.cs
===================================================================
--- stable/HeuristicLab.Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/GaussianProcessRegressionTest.cs	(revision 15278)
+++ stable/HeuristicLab.Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/GaussianProcessRegressionTest.cs	(revision 15292)
@@ -22,5 +22,4 @@
 using System;
 using System.Linq;
-using System.Threading;
 using HeuristicLab.Common;
 using HeuristicLab.Problems.DataAnalysis;
@@ -39,5 +38,4 @@
     }
 
-    private EventWaitHandle trigger = new AutoResetEvent(false);
     private Exception ex;
 
@@ -66,9 +64,7 @@
 
       alg.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(cv_ExceptionOccurred);
-      alg.Stopped += new EventHandler(cv_Stopped);
 
       alg.Prepare();
       alg.Start();
-      trigger.WaitOne();
       if (ex != null) throw ex;
 
@@ -79,8 +75,4 @@
       ex = e.Value;
     }
-
-    private void cv_Stopped(object sender, EventArgs e) {
-      trigger.Set();
-    }
   }
 }
Index: stable/HeuristicLab.Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/GradientBoostingTest.cs
===================================================================
--- stable/HeuristicLab.Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/GradientBoostingTest.cs	(revision 15278)
+++ stable/HeuristicLab.Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/GradientBoostingTest.cs	(revision 15292)
@@ -3,7 +3,5 @@
 using System.IO;
 using System.Linq;
-using System.Threading;
 using HeuristicLab.Data;
-using HeuristicLab.Optimization;
 using HeuristicLab.Problems.DataAnalysis;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -242,5 +240,5 @@
       #endregion
 
-      RunAlgorithm(gbt);
+      gbt.Start();
 
       Console.WriteLine(gbt.ExecutionTime);
@@ -270,5 +268,5 @@
       #endregion
 
-      RunAlgorithm(gbt);
+      gbt.Start();
 
       Console.WriteLine(gbt.ExecutionTime);
@@ -298,22 +296,9 @@
       #endregion
 
-      RunAlgorithm(gbt);
+      gbt.Start();
 
       Console.WriteLine(gbt.ExecutionTime);
       Assert.AreEqual(0.061954221604374943, ((DoubleValue)gbt.Results["Loss (train)"].Value).Value, 1E-6);
       Assert.AreEqual(0.06316303473499961, ((DoubleValue)gbt.Results["Loss (test)"].Value).Value, 1E-6);
-    }
-
-    // same as in SamplesUtil
-    private void RunAlgorithm(IAlgorithm a) {
-      var trigger = new EventWaitHandle(false, EventResetMode.ManualReset);
-      Exception ex = null;
-      a.Stopped += (src, e) => { trigger.Set(); };
-      a.ExceptionOccurred += (src, e) => { ex = e.Value; trigger.Set(); };
-      a.Prepare();
-      a.Start();
-      trigger.WaitOne();
-
-      Assert.AreEqual(ex, null);
     }
 
Index: stable/HeuristicLab.Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/SupportVectorMachineTest.cs
===================================================================
--- stable/HeuristicLab.Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/SupportVectorMachineTest.cs	(revision 15278)
+++ stable/HeuristicLab.Tests/HeuristicLab.Algorithms.DataAnalysis-3.4/SupportVectorMachineTest.cs	(revision 15292)
@@ -23,5 +23,4 @@
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading;
 using HeuristicLab.Algorithms.DataAnalysis;
 using HeuristicLab.Common;
@@ -50,5 +49,4 @@
     }
 
-    private EventWaitHandle trigger = new AutoResetEvent(false);
     private Exception ex;
 
@@ -71,9 +69,7 @@
 
       cv.ExceptionOccurred += new EventHandler<EventArgs<Exception>>(cv_ExceptionOccurred);
-      cv.Stopped += new EventHandler(cv_Stopped);
 
       cv.Prepare();
       cv.Start();
-      trigger.WaitOne();
       if (ex != null) throw ex;
 
@@ -102,8 +98,4 @@
       ex = e.Value;
     }
-
-    private void cv_Stopped(object sender, EventArgs e) {
-      trigger.Set();
-    }
   }
 }
Index: stable/HeuristicLab.Tests/HeuristicLab.Scripting-3.3/Script Sources/GUIAutomationScriptSource.cs
===================================================================
--- stable/HeuristicLab.Tests/HeuristicLab.Scripting-3.3/Script Sources/GUIAutomationScriptSource.cs	(revision 15278)
+++ stable/HeuristicLab.Tests/HeuristicLab.Scripting-3.3/Script Sources/GUIAutomationScriptSource.cs	(revision 15292)
@@ -1,9 +1,6 @@
-﻿using System;
-using System.Linq;
-using System.Threading;
+﻿using System.Linq;
 using System.Windows.Forms;
 
 using HeuristicLab.Algorithms.GeneticAlgorithm;
-using HeuristicLab.Core;
 using HeuristicLab.MainForm;
 using HeuristicLab.MainForm.WindowsForms;
@@ -13,6 +10,4 @@
 
 public class GUIAutomationScript : HeuristicLab.Scripting.CSharpScriptBase {
-  readonly ManualResetEvent mutex = new ManualResetEvent(false);
-
   public override void Main() {
     var ga = new GeneticAlgorithm {
@@ -27,8 +22,5 @@
       ga.PopulationSize.Value *= 2;
     }
-
-    experiment.ExecutionStateChanged += OnExecutionStateChanged;
     experiment.Start();
-    mutex.WaitOne();
 
     vars.experiment = experiment;
@@ -39,8 +31,3 @@
     bubbleChart.Controls.OfType<ComboBox>().Single(x => x.Name == "xAxisComboBox").SelectedItem = "PopulationSize";
   }
-
-  private void OnExecutionStateChanged(object sender, EventArgs e) {
-    if (((IExecutable)sender).ExecutionState == ExecutionState.Stopped)
-      mutex.Set();
-  }
 }
Index: stable/HeuristicLab.Tests/HeuristicLab.Scripting-3.3/ScriptingUtils.cs
===================================================================
--- stable/HeuristicLab.Tests/HeuristicLab.Scripting-3.3/ScriptingUtils.cs	(revision 15278)
+++ stable/HeuristicLab.Tests/HeuristicLab.Scripting-3.3/ScriptingUtils.cs	(revision 15292)
@@ -21,5 +21,4 @@
 
 using System;
-using System.Threading;
 using HeuristicLab.Scripting;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -33,11 +32,7 @@
 
     public static void RunScript(CSharpScript s) {
-      var trigger = new EventWaitHandle(false, EventResetMode.ManualReset);
       Exception ex = null;
-
-      s.ScriptExecutionFinished += (sender, e) => { ex = e.Value; trigger.Set(); };
-      s.ExecuteAsync();
-      trigger.WaitOne();
-
+      s.ScriptExecutionFinished += (sender, e) => { ex = e.Value; };
+      s.Execute();
       Assert.IsNull(ex);
     }
Index: stable/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- stable/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 15278)
+++ stable/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 15292)
@@ -446,5 +446,4 @@
   <ItemGroup>
     <Compile Include="AssemblyInitializer.cs" />
-    <Compile Include="HeuristicLab-3.3\AlgorithmExtensions.cs" />
     <Compile Include="HeuristicLab-3.3\CloningConstructorTest.cs" />
     <Compile Include="HeuristicLab-3.3\CollectObjectGraphTest.cs" />
