     
     /// Suspend if `result` satisfies `predicate` with specific queue.
     public final func suspend(queue: dispatch_queue_t, _ predicate: (Result) -> Bool) -> SDTask<Result> {
-        let task = SDTask<Result>(queue: queue, suspend: predicate) { self.result }
+        var storage: Result!
+        let task = SDTask<Result>(queue: queue, suspend: predicate) { storage }
         return _lck.synchronized {
             if _result == nil {
-                _notify.append(task)
+                _notify.append {
+                    storage = $0
+                    task.signal()
+                }
             } else {
+                storage = _result
                 task.signal()
             }
             return task

    
    private let sem: dispatch_semaphore_t = dispatch_semaphore_create(0)
    
    private var _notify: [SDAtomic] = []
    
    private var _lck: SDSpinLock = SDSpinLock()
    private var _result: Result?

    static func createBlock(block: () -> Result, suspend: ((Result) -> Bool)?) -> (SDAtomic) -> Void {
        return { atomic in
            let _self = atomic as! SDTask<Result>
            if let result = _self._result {
                if suspend?(result) != true {
                    _self._notify.forEach { $0(result) }
                }
                _self._notify = []
            } else {
                let result = block()
                _self._lck.synchronized { _self._result = result }
                dispatch_semaphore_signal(_self.sem)
                _self.signal()
            }
        }
    }
