 				// Check if the status has been bumped to `terminating` due to a
 				// concurrent termination event that has not been caught in the main
 				// protected section.
-				//
-				// Note that as the check happens before acquiring `updateLock`, it
-				// could be a false positive, and thus a second check after the lock is
-				// acquired is mandatory.
 				if !shouldDispose, case .terminating = signal.state {
 					signal.sendLock.lock()
 
-					// Acquire `updateLock`. If the termination has still not yet been
-					// handled, take it over and bump the status to `terminated`.
-					signal.updateLock.lock()
-
-					if case let .terminating(snapshot) = signal.state {
-						signal.state = .terminated
-						signal.updateLock.unlock()
-
+					if let snapshot = signal.shouldReallyTerminate() {
 						for observer in snapshot.observers {
 							observer.action(snapshot.associated)
 						}
 
 						shouldDispose = true
-					} else {
-						signal.updateLock.unlock()
 					}
 
 					signal.sendLock.unlock()


					// Check if the status has been bumped to `terminating` due to a
					// concurrent or a recursive termination event.
					//
					// Note that as the check happens before acquiring `updateLock`, it
					// could be a false positive, and thus a second check after the lock
					// is acquired is mandatory.
					if case .terminating = signal.state {
						// Acquire `updateLock`. If the termination has still not yet been
						// handled, take it over and bump the status to `terminated`.
						signal.updateLock.lock()

						if case let .terminating(snapshot) = signal.state {
							signal.state = .terminated
							signal.updateLock.unlock()

							for observer in snapshot.observers {
								observer.action(snapshot.associated)
							}

							shouldDispose = true
						} else {
							signal.updateLock.unlock()
						}
					}
				}


			//   also be checked again after the locks are acquired. Fail gracefully
			//   if the state has changed since the relaxed read, i.e. a concurrent
			//   sender has already handled the termination event.
			//
			// Exploiting the relaxation of reads, please note that false positives
			// are intentionally allowed in the `terminating` checks below. As a
			// result, normal event deliveries need not acquire `updateLock`.
			// Nevertheless, this should not cause the termination event being
			// sent multiple times, since `shouldReallyTerminate` would not
			// respond to false positives.

			if event.isTerminating {
				// Recursive events are disallowed for `value` events, but are permitted
