0

I'm converting my Swift app to use Combine as well as async/await and I'm trying to understand what's the best way to handle interactions between asynchronous functions and the main thread.

Here's an asynchronous function that loads a user:

class AccountManager {

    static func fetchOrLoadUser() async throws -> AppUser {
        if let user = AppUser.current.value {
            return user
        }
    
        let syncUser = try await loadUser()
        let user = try AppUser(syncUser: syncUser)
    
        AppUser.current.value = user // [warning]: "Publishing changes from background threads is not allowed"
        return user
    }
}

And a class:

class AppUser {

    static var current = CurrentValueSubject<AppUser?,Never>(nil)

    // ...
}

Note: I chose to use CurrentValueSubject because it allows me to both (1) read this value synchronously whenever I need it and (2) subscribe for changes.

Now, on the line marked above I get the error Publishing changes from background threads is not allowed, which I understand. I see different ways to solve this issue:

1. Mark whole AccountManager class as @MainActor

Since most of the work done in asynchronous functions is to wait for network results, I'm wondering if there is an issue with simply running everything on the main thread. Would that cause performance issues or not?

2. Englobe error line in DispatchQueue.main.sync

Is that a reasonable solution, or would that cause threading problems like deadlocks?

3. Use DispatchGroup with enter(), leave() and wait()

Like in this answer. Is there a difference at all with solution #2? Because this solution needs more lines of code so I'd rather not use it if possible —I prefer clean code.

Morpheus
  • 1,189
  • 2
  • 11
  • 33
  • You can annotate individual functions or properties with @MainActor. Doing it for the whole class makes sense if all functions need to perform on main thread. – cora Sep 06 '22 at 14:22
  • Thanks for the tip! Am I right that `@MainActor` makes sense for asynchronous code relying on network calls but it shouldn't be used for heavy computation code? – Morpheus Sep 06 '22 at 14:35
  • Why even have the side effect "AppUser.current.value = user" in there at all, make it the caller's problem to assign the variable on the right thread? – Shadowrun Sep 06 '22 at 15:40

1 Answers1

1

You can wrap the call in an await MainActor.run { } block. I think this is the most Swifty way of doing that.

You should not use Dispatch mechanism while using Swift Concurrency, event though I think DispatchQueue.main.async { } is safe to use here.

The @MainActor attribute is safe but shouldn’t be used on anObservableObject and could potentially slow down the UI if CPU-bound code is run in a method of the annotated type.

Louis Lac
  • 5,298
  • 1
  • 21
  • 36