Thread safe combine publisher to AsyncStream

Question

I try to figure out is this approach thread safe if getStream() and update(value: ...) will be called on difference thread simultaneously?

final class SomeNotifier {

static let shared = SomeNotifier()

private let value = PassthroughSubject<String, Never>()
private var cancellables: Set<AnyCancellable> = []

private init() {}

func getStream() -> AsyncStream<String> {
    return AsyncStream { [weak self] continuation in
        guard let self = self else { return }

        self.value.sink { completion in
            switch completion {
            case .finished:
                continuation.finish()
            case .failure:
                continuation.finish()
            }
        } receiveValue: { value in
            continuation.yield(value)
        }
        .store(in: &cancellables)
    }
}

func update(value: String) {
    self.value.send(value)
}

I want to have some repository that can notify different observers about change of internal state

Is it really necessary to reinvent the wheel? Given that `value.values` is an async stream already? — matt, Mar 27 '23 at 11:42
And if there's a thread doubt why not insert `receive(on)`? Another wheel that doesn't have to be reinvented. — matt, Mar 27 '23 at 11:44
So what happens if the stream ins cancelled? This seems very unnecessary and unsafe — lorem ipsum, Mar 27 '23 at 12:22
I think cancellation is ok. Not ok is calling `getStream`, because it's calling `store(in:)`, but `Set` is not thread safe. — Cy-4AH, Mar 27 '23 at 12:48
about cancellation - in my case this object will be alive all time when app alive — FuzzzzyBoy, Mar 27 '23 at 13:13

Rob · Accepted Answer · 2023-03-31T20:26:18.117

In a variation of Cy-4AH’s answer (subsequently deleted), which uses an actor for synchronization, I would make sure to add an onTermination handler to remove the associated continuation if the asynchronous sequence was canceled. E.g.:

actor Notifier<Output> {
    private var continuations: [UUID: AsyncStream<Output>.Continuation] = [:]

    func values() -> AsyncStream<Output> {
        AsyncStream { continuation in
            let id = UUID()
            continuations[id] = continuation

            continuation.onTermination = { _ in
                Task { await self.cancel(id) }
            }
        }
    }

    func send(_ value: Output) {
        for continuation in continuations.values {
            continuation.yield(value)
        }
    }
}

private extension Notifier {
    func cancel(_ id: UUID) {
        continuations[id] = nil
    }
}

There are tons of variations on the theme, but the details of the implementation matter less than the general observations of (a) the use of an actor; and (b) the use of the onTermination handler to clean up in case the notifier object might outlive the individual sequences.

FWIW, if I really wanted to create a singleton for String notifications:

final class StringNotifier: Sendable {
    static let shared = StringNotifier()

    private init() { }

    private let notifier = Notifier<String>()

    func values() async -> AsyncStream<String> {
        await notifier.values()
    }

    func send(_ value: String) {
        Task { await notifier.send(value) }
    }
}

As an aside, I generally prefer to use AsyncChannel for these sorts of “subject” like behaviors, but a single channel does not allow multiple observers and if you try to have a collection of these channels, it does not (currently) provide the required onTermination-like handler.

FWIW, if you were to use Combine PassthroughSubject, it might look like:

actor CombineNotifier<Output> {
    private let subject = PassthroughSubject<Output, Never>()
    private var cancellables: [UUID: AnyCancellable] = [:]

    func values() -> AsyncStream<Output> {
        AsyncStream { continuation in
            let id = UUID()

            cancellables[id] = subject.sink { _ in
                continuation.finish()
            } receiveValue: { value in
                continuation.yield(value)
            }

            continuation.onTermination = { _ in
                Task { await self.cancel(id) }
            }
        }
    }

    func send(_ value: Output) {
        subject.send(value)
    }
}

private extension CombineNotifier {
    func cancel(_ id: UUID) {
        cancellables[id] = nil
    }
}

Again, it is an actor to provide thread-safe interaction and uses onTermination to clean up individual sequences.

Thread safe combine publisher to AsyncStream

1 Answers1