 				if case let .alive(observers, _) = state {
 					self.state = .terminating(observers, .init(event))
 					self.stateLock.unlock()
-
-					// Check whether the terminating state has been handled by a
-					// concurrent sender. If not, handle it.
-					if self.tryToCommitTermination() == .shouldDispose {
-						self.disposable.dispose()
-					}
 				} else {
 					self.stateLock.unlock()
 				}
 			} else {
-				var result = OperationResult.none
-
 				self.sendLock.lock()
 				self.stateLock.lock()
 

		///
		/// - precondition: `stateLock` must not be acquired by the caller.
		///
		/// - parameters:
		///   - sendLock: `sendLock` if the caller has acquired it. If not specified,
		///               `tryTerminate` would attempt to acquire the `sendLock`.
		///
		/// - returns: `.shouldDispose` if the attempt succeeds. `.none` otherwise.
		private func tryToCommitTermination(acquired sendLock: Lock? = nil) -> OperationResult {
			assert(sendLock == nil || sendLock === self.sendLock,
			       "`tryTerminate` receives a lock that is not the `sendLock` of the signal.")
			func commit() -> OperationResult {
				// Acquire `stateLock`. If the termination has still not yet been
				// handled, take it over and bump the status to `terminated`.
				self.stateLock.lock()

				if case let .terminating(observers, terminationKind) = self.state {
					self.state = .terminated
					self.stateLock.unlock()

					if let event = terminationKind.materialize() {
						for observer in observers {


					return .shouldDispose
				}
			}

			stateLock.unlock()
			return .none
		}

		/// Try to dispose of the signal silently if the `Signal` has deinitialized and
