             dispatch_barrier_sync(barrier) {
                 switch self.unsafeStatus {
                 case .Fulfilled(let result):
-                    callback!(result)
+                    Promise.dispatch(on: queue) {
+                        callback(result)
+                    }
                     
                 case .Rejected:
                     break
                     
                 case .Pending:
-                    self.succeededCallbacks.append(callback!)
+                    self.succeededCallbacks.append((callback, queue))
                 }
             }
         }

                    break
                    
                case .Rejected(let error):
                    callback!(error)
                    
                case .Pending:
                    self.failedCallbacks.append(callback!)
                }
            }
        }
        return self
    }
    
    // MARK: - Cancel

        }
    }
    
    /**
     Constructs a pending promise connected to a parent promise.
     
     By connecting to a parent promise, cancelling this promise will also result in cancelling the parent.
     
     - paramater parent:    The parent promise for the newly constructed promise.
     - parameter block:     A block which will be executed directly, which can throw an error which will reject the promise.
     
     The block takes three arguments:
     
     `promise`: The constructed promise.<br/>
     `fulfill`: The block to fulfill the promise with a value.<br/>
     `reject`: The block to reject the promise with an error.<br/>
     */
    public init<T>(parent: Promise<T>, @noescape _ block: (promise: Promise<Value>, fulfill: (Value) -> Void, reject: (ErrorType) -> Void) throws -> Void) {
        super.init()
        
        do {
            try block(promise: self, fulfill: fulfill, reject: reject)
        } catch let error {
            reject(error)
        }
        
        self.parent = parent
        parent.nonCancelledChildrenCount += 1
    }
    
    // MARK: - Status
    
    /**
