     }
     
     private func deferCompletionHandler(handler: FutureCompletionHandler<T>) {
-        dispatch_sync(self.syncQueue) {
-            self.stateHandlers.append(handler)
-        }
+        self.stateHandlers.append(handler)
     }
     
+    
     public func onSuccess(context: ExecutionContext = defaultExecutionContext, successHandler: T -> Void) -> Future<T> {
-        let completionHandler = FutureCompletionHandler.Success(task: successHandler, context: context)
-        switch self.state {
-        case .Pending:
-            self.deferCompletionHandler(completionHandler)
-        case .Fulfilled(_):
-            self.executeCompletionHandler(completionHandler)
-        default:
-            break
+        dispatch_async(self.syncQueue) {
+            let completionHandler = FutureCompletionHandler.Success(task: successHandler, context: context)
+            switch self.state {
+            case .Pending:
+                self.deferCompletionHandler(completionHandler)
+            case .Fulfilled(_):
+                self.executeCompletionHandler(completionHandler)
+            default:
+                break
+            }
         }
         return self
     }
     
     public func onFailure(context: ExecutionContext = defaultExecutionContext, failureHandler: ErrorType -> Void) -> Future<T> {
-        let completionHandler = FutureCompletionHandler<T>.Failure(task: failureHandler, context: context)
-        switch self.state {
-        case .Pending:
-            self.deferCompletionHandler(completionHandler)
-        case .Rejected(_):
-            self.executeCompletionHandler(completionHandler)
-        default:
-            break
+        dispatch_async(self.syncQueue) {
+            let completionHandler = FutureCompletionHandler<T>.Failure(task: failureHandler, context: context)
+            switch self.state {
+            case .Pending:
+                self.deferCompletionHandler(completionHandler)
+            case .Rejected(_):
+                self.executeCompletionHandler(completionHandler)
+            default:
+                break
+            }
         }
         return self
     }
     
     public func finally(context: ExecutionContext = defaultExecutionContext, handler: Void -> Void) -> Future<T> {
-        let completionHandler = FutureCompletionHandler<T>.Finally(task: handler, context: context)
-        switch self.state {
-        case .Pending:
-            self.deferCompletionHandler(completionHandler)
-        default:
-            self.executeCompletionHandler(completionHandler)
+        dispatch_async(self.syncQueue) {
+            let completionHandler = FutureCompletionHandler<T>.Finally(task: handler, context: context)
+            switch self.state {
+            case .Pending:
+                self.deferCompletionHandler(completionHandler)
+            default:
+                self.executeCompletionHandler(completionHandler)
+            }
         }
         return self
     }

        }
    }
    
    private func executeCompletionHandler(handler: FutureCompletionHandler<T>) {
        switch (handler, self.state) {
        case (.Success(let successHandler, let context), .Fulfilled(let value)):

public typealias ExecutionContext = (task: Void throws -> Void) -> (Void -> Future<Void>)


let defaultExecutionContext: ExecutionContext = onMainQueue

private enum FutureCompletionHandler<T> {
    case Success(task: T -> Void, context: ExecutionContext)
