     }
     
     public func onComplete(executionContext:ExecutionContext, complete:Try<T> -> Void) -> Void {
-        self.futureQueue.async {
+        self.futureQueue.sync {
             let savedCompletion : OnComplete = {result in
                 executionContext.execute {
                     complete(result)


    private var result:Try<T>?

    typealias OnComplete                                    = Try<T> -> Void
    private var saveCompletes                               = [OnComplete]()
    private let futureQueue : Queue
    
    public var completed : Bool {
        return self.result != nil
    }
    
    public init() {
        self.futureQueue = Queue.simpleFutures
    }
    
    public init(queue:Queue) {
        self.futureQueue = queue
    }

    // should be future mixin
    internal func complete(result:Try<T>) {
        self.futureQueue.async {
            if self.result != nil {
                SimpleFuturesException.futureCompleted.raise()
            }

        self.future = Future<T>()
    }

    public func completeWith(future:Future<T>) {
        self.completeWith(self.future.defaultExecutionContext, future:future)
    }
