 
   /// **internal use only**
   override public func _asyncNinja_retainUntilFinalization(_ releasable: Releasable) {
-    _locking.locker(self, releasable) { (self_, releasable) -> Void in
-      if !self_._isComplete {
-        self_._releasePool.insert(releasable)
-      }
-    }
+    _locking.lock()
+    if !_isComplete {
+      _releasePool.insert(releasable)
+    }
+    _locking.unlock()
   }
 
   /// **internal use only**
   override public func _asyncNinja_notifyFinalization(_ block: @escaping () -> Void) {
-    let shouldCallBlockNow = _locking.locker(self, block) { (self_, block) -> Bool in
-      if self_._isComplete {
-        return true
-      } else {
-        self_._releasePool.notifyDrain(block)
-        return false
-      }
-    }
+    let shouldCallBlockNow: Bool
+    _locking.lock()
+    if _isComplete {
+      shouldCallBlockNow = true
+    } else {
+      _releasePool.notifyDrain(block)
+      shouldCallBlockNow = false
+    }
+    _locking.unlock()
 
     if shouldCallBlockNow {
       block()

    _ block: @escaping (_ completion: Fallible<Success>, _ originalExecutor: Executor) -> Void
    ) -> AnyObject? {

    let (oldState, handler) = _locking
      .locker(self, executor, block) { (self_, executor, block) -> (PromiseState<Success>, AnyObject?) in
        let oldState = self_._state
        let (newState, handler) = oldState.subscribe(owner: self_, executor: executor, block)
        self_._state = newState
        return (oldState, handler)
    }

    oldState.didSubscribe(executor: executor, block)


    from originalExecutor: Executor? = nil
    ) -> Bool {

    _locking.lock()
    let oldState = _state
    let (newState, completionResult) = oldState.complete(completion: completion)
    _state = newState
    _locking.unlock()

    oldState.didComplete(completion, from: originalExecutor)

