Back Signal.Core.state with Atomic.

Author: andersio

Sources/Signal.swift

@@ -100,7 +100,12 @@ public final class Signal<Value, Error: Swift.Error> {
 		/// Nevertheless, this should not cause the termination event being
 		/// sent multiple times, since `tryTerminate` would not respond to false
 		/// positives.
-		private var state: State
+		private var state: State {
+			get { return _state.value }
+			set { _state.value = newValue }
+		}
+
+		private let _state: Atomic<State>
 
 		/// Used to ensure that state updates are serialized.
 		private let updateLock: Lock
@@ -112,7 +117,7 @@ public final class Signal<Value, Error: Swift.Error> {
 		private var hasDeinitialized: Bool
 
 		fileprivate init(_ generator: (Observer) -> Disposable?) {
-			state = .alive(AliveState(observers: Bag()))
+			_state = Atomic(.alive(AliveState(observers: Bag())))
 
 			updateLock = Lock.make()
 			sendLock = Lock.make()
@@ -163,43 +168,19 @@ public final class Signal<Value, Error: Swift.Error> {
 			} else {
 				var result = OperationResult.none
 
-				// The `terminating` status check is performed twice for two different
-				// purposes:
-				//
-				// 1. Within the main protected section
-				//    It guarantees that a recursive termination event sent by a
-				//    downstream consumer, is immediately processed and need not compete
-				//    with concurrent pending senders (if any).
-				//
-				//    Termination events sent concurrently may also be caught here, but
-				//    not necessarily all of them due to data races.
-				//
-				// 2. After the main protected section
-				//    It ensures the termination event sent concurrently that are not
-				//    caught by (1) due to data races would still be processed.
-				//
-				// The related PR on the race conditions:
-				// https://github.com/ReactiveCocoa/ReactiveSwift/pull/112
-
 				self.sendLock.lock()
 
 				if case let .alive(state) = self.state {
 					for observer in state.observers {
 						observer.action(event)
 					}
-
-					// Check if the status has been bumped to `terminating` due to a
-					// concurrent or a recursive termination event.
-					if case .terminating = self.state {
-						result = self.tryToCommitTermination(acquired: self.sendLock)
-					}
 				}
 
 				self.sendLock.unlock()
 
-				// 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.
+				// Check if any observer or any concurrent sender has been bumped to
+				// `terminating` due to a concurrent termination event that has not been
+				// caught in the main protected section.
 				if result == .none, case .terminating = self.state {
 					result = self.tryToCommitTermination()
 				}