     _ 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)
-    }
+    _locking.lock()
+    let oldState = _state
+    let (newState, handler) = oldState.subscribe(owner: self, executor: executor, block)
+    _state = newState
+    _locking.unlock()
 
     oldState.didSubscribe(executor: executor, block)
 


  /// Returns either completion for complete `Promise` or nil otherwise
  override public var completion: Fallible<Success>? {
    return _locking.locker(self) { $0._completion }
  }

  private var _completion: Fallible<Success>? {


  /// **internal use only**
  override public func _asyncNinja_retainUntilFinalization(_ releasable: Releasable) {
    _locking.lock()
    if !_isComplete {
      _releasePool.insert(releasable)
    }
    _locking.unlock()
  }

  /// **internal use only**
  override public func _asyncNinja_notifyFinalization(_ block: @escaping () -> Void) {
    let shouldCallBlockNow: Bool
    _locking.lock()
    if _isComplete {
      shouldCallBlockNow = true
    } else {
      _releasePool.notifyDrain(block)
      shouldCallBlockNow = false
    }
    _locking.unlock()

    if shouldCallBlockNow {
      block()
