             // clear `_initClosure` & all StateMachine's handlers to prevent retain cycle
             $0.addEventHandler(.Fulfill, order: 255) { context in
                 weakSelf?._initClosure = nil
+                weakSelf?._performInitClosure = nil
                 weakSelf?.machine?.removeAllHandlers()
             }
             $0.addEventHandler(.Reject, order: 255) { context in
                 weakSelf?._initClosure = nil
+                weakSelf?._performInitClosure = nil
                 weakSelf?.machine?.removeAllHandlers()
             }
             
         }
         
-        var progressHandler: ProgressHandler
-        var fulfillHandler: FulFillHandler
-        var rejectHandler: _RejectHandler
-        
-        if weakified {
-            progressHandler = { [weak self] (progress: Progress) in
-                if let self_ = self {
-                    let oldProgress = self_.progress
-                    self_.machine <-! (.Progress, (oldProgress, progress))
-                }
-            }
-            
-            fulfillHandler = { [weak self] (value: Value) in
-                if let self_ = self {
-                    self_.machine <-! (.Fulfill, value)
-                }
-            }
-            
-            rejectHandler = { [weak self] (errorInfo: ErrorInfo) in
-                if let self_ = self {
-                    self_.machine <-! (.Reject, errorInfo)
-                }
-            }
-        }
-        else {
-            progressHandler = { (progress: Progress) in
-                let oldProgress = self.progress
-                self.machine <-! (.Progress, (oldProgress, progress))
-                return
-            }
-            
-            fulfillHandler = { (value: Value) in
-                self.machine <-! (.Fulfill, value)
-                return
-            }
-            
-            rejectHandler = { (errorInfo: ErrorInfo) in
-                self.machine <-! (.Reject, errorInfo)
-                return
-            }
-        }
-        
-        _initClosure(machine: self.machine, progress: progressHandler, fulfill: fulfillHandler, _reject: rejectHandler, configure: configuration)
-        
-        let userPauseClosure = configuration.pause
-        let userResumeClosure = configuration.resume
-        let userCancelClosure = configuration.cancel
-        
-        // add parentTask-pause/resume/cancel functionalities after retrieving user-defined configuration
-        configuration.pause = { [weak self] in
-            userPauseClosure?()
-            
-            var task: _Task? = self
-            while let parentTask = task?._parentTask {
-                if parentTask._weakified { break }
-                
-                parentTask.pause()
-                task = parentTask
-            }
-            
-        }
-        configuration.resume = { [weak self] in
-            userResumeClosure?()
-            
-            var task: _Task? = self
-            while let parentTask = task?._parentTask {
-                if parentTask._weakified { break }
-                
-                parentTask.resume()
-                task = parentTask
-            }
-        }
-        configuration.cancel = { [weak self] in
-            userCancelClosure?()
-            
-            var task: _Task? = self
-            while let parentTask = task?._parentTask {
-                if parentTask._weakified { break }
-                
-                parentTask.cancel()
-                task = parentTask
-            }
+        self._initClosure = _initClosure
+        
+        // will be invoked only once
+        self._performInitClosure = { [weak self] in
+            
+            if let self_ = self {
+                
+                var progressHandler: ProgressHandler
+                var fulfillHandler: FulFillHandler
+                var rejectHandler: _RejectHandler
+                
+                if weakified {
+                    progressHandler = { [weak self_] (progress: Progress) in
+                        if let self_ = self_ {
+                            let oldProgress = self_.progress
+                            self_.machine <-! (.Progress, (oldProgress, progress))
+                        }
+                    }
+                    
+                    fulfillHandler = { [weak self_] (value: Value) in
+                        if let self_ = self_ {
+                            self_.machine <-! (.Fulfill, value)
+                        }
+                    }
+                    
+                    rejectHandler = { [weak self_] (errorInfo: ErrorInfo) in
+                        if let self_ = self_ {
+                            self_.machine <-! (.Reject, errorInfo)
+                        }
+                    }
+                }
+                else {
+                    progressHandler = { (progress: Progress) in
+                        let oldProgress = self_.progress
+                        self_.machine <-! (.Progress, (oldProgress, progress))
+                        return
+                    }
+                    
+                    fulfillHandler = { (value: Value) in
+                        self_.machine <-! (.Fulfill, value)
+                        return
+                    }
+                    
+                    rejectHandler = { (errorInfo: ErrorInfo) in
+                        self_.machine <-! (.Reject, errorInfo)
+                        return
+                    }
+                }
+            
+                _initClosure(machine: self_.machine, progress: progressHandler, fulfill: fulfillHandler, _reject: rejectHandler, configure: configuration)
+                
+                let userPauseClosure = configuration.pause
+                let userResumeClosure = configuration.resume
+                let userCancelClosure = configuration.cancel
+                
+                // add parentTask-pause/resume/cancel functionalities after retrieving user-defined configuration
+                configuration.pause = { [weak self_] in
+                    userPauseClosure?()
+                    
+                    var task: _Task? = self_
+                    while let parentTask = task?._parentTask {
+                        if parentTask._weakified { break }
+                        
+                        parentTask.pause()
+                        task = parentTask
+                    }
+                    
+                }
+                configuration.resume = { [weak self_] in
+                    userResumeClosure?()
+                    
+                    var task: _Task? = self_
+                    while let parentTask = task?._parentTask {
+                        if parentTask._weakified { break }
+                        
+                        parentTask.resume()
+                        task = parentTask
+                    }
+                }
+                configuration.cancel = { [weak self_] in
+                    userCancelClosure?()
+                    
+                    var task: _Task? = self_
+                    while let parentTask = task?._parentTask {
+                        if parentTask._weakified { break }
+                        
+                        parentTask.cancel()
+                        task = parentTask
+                    }
+                }
+                
+            }
+        
+        }
+        
+        if !paused {
+            self.resume()
         }
     }
     

    
    internal typealias Machine = StateMachine<TaskState, TaskEvent>
    
    internal var machine: Machine!
    
    // store initial parameters for cloning task when using `try()`
    internal var _initClosure: _InitClosure?    // will be nil on fulfilled/rejected
    
    /// progress value
    public internal(set) var progress: Progress?

    
    public override func resume() -> Bool
    {
        // always try `_performInitClosure` only once on `resume()`
        // even when to-Resume-transition fails, e.g. already been fulfilled/rejected
        self._performInitClosure?()
        self._performInitClosure = nil
        
        return self.machine <-! .Resume
    }
    
