Параллелизм Swift кажется случайным при использовании MainActor?

Я пытался найти способ вызвать corelocation requestLocation в основном потоке (что, очевидно, необходимо).

Нажимать requestLocation в основной теме не обязательно. Вы можете вызвать его из любого потока.

Проблема в том, что вы создаете CLLocationManager не в той теме. Из документов,

Core Location вызывает методы вашего объекта-делегата, используя RunLoop потока, в котором вы инициализировали CLLocationManager объект. Эта ветка сама должна иметь активный значок RunLoop, как в основной ветке вашего приложения.

В случае неудачи вы создаете LocationManager (который, в свою очередь, создает CLLocationManager) неизолированным асинхронным методом. Это будет выполняться в каком-то потоке из совместного пула потоков, который наверняка не имеет RunLoop. Поэтому методы делегата не вызываются.

// locationManager is initialised in the View initialiser, which is run on the main thread
// so these work
let location = try await locationManager.currentLocation
let location2 = try await locationManager.work()

// test2 is isolated to the main actor, so "LocationManager()" is run on the main thread too
let location4 = try await APIService.shared.test2()

// neither test nor test3 are isolated to the main actor, so LocationManager is not created on the main thread
// the fact that 'currentLocation2' is isolated to the main thread doesn't matter
let location3 = try await APIService.shared.test()
let location5 = try await APIService.shared.test3()

Что касается того, какой поток вызывает requestLocation (не имеет отношения к проблеме — просто для вашей информации), основной поток всегда будет вызывать вызов currentLocation2, поскольку он изолирован от основного актера, а неосновной поток всегда будет вызывать вызов. в currentLocation, потому что он не изолирован. Вы можете проверить это, нажав MainActor.shared.assertIsolated(). Если он вылетает, вы не на главном актере.

Обратите внимание, что ваш код содержит множество предупреждений, связанных с параллелизмом. Попробуйте включить полную проверку параллелизма и убедитесь в этом сами.

Я бы сделал LocationManageractor так, чтобы он был Sendable и, следовательно, его свойства/методы можно было безопасно вызывать из любого места. Еще я бы сделал APIService итоговое занятие, чтобы его тоже можно было сделать Sendable. Это делает экземпляр shared безопасным.

Обратите внимание, что в настоящее время, если вы получаете currentLocation, хотя текущее продолжение не возобновилось, вы перезапишете существующее продолжение, в результате чего resume никогда не будет вызываться для этого перезаписанного продолжения.

Здесь я исправил код для удаления предупреждений, связанных с параллелизмом:

actor LocationManager: NSObject, CLLocationManagerDelegate {

    private let locationManager = CLLocationManager()
    
    override init() {
        super.init()
        locationManager.delegate = self
    }

    func checkAuthorization() {
        switch locationManager.authorizationStatus {
        case .notDetermined:
            locationManager.requestWhenInUseAuthorization()
        default:
            return
        }
    }
    
    private var continuation: CheckedContinuation<CLLocation, Error>?

    enum LocationError: Error {
        case locationInProgress
    }
    
    var currentLocation: CLLocation {
        get async throws {
            return try await withCheckedThrowingContinuation { continuation in
                if self.continuation != nil {
                    continuation.resume(throwing: LocationError.locationInProgress)
                } else {
                    self.continuation = continuation
                    locationManager.requestLocation()
                }
            }
        }
    }

    func updateLocation(_ location: CLLocation) {
        continuation?.resume(returning: location)
        continuation = nil
    }
    
    func locationError(_ error: Error) {
        continuation?.resume(throwing: error)
        continuation = nil
    }
    
    nonisolated func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        if let lastLocation = locations.last {
            Task {
                await updateLocation(lastLocation)
            }
        }
    }

    nonisolated func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
        Task {
            await locationError(error)
        }
    }

    func work() async throws -> CLLocation {
        return try await currentLocation
    }
}

// also consider making this a struct
final class APIService: Sendable {
    static let shared = APIService()
    
    let locationManager = LocationManager()
    private init() {
    }

    func test() async throws -> String {
        return try await String(describing: locationManager.currentLocation)
    }
}

Теперь при запуске приложения вам просто нужно получить доступ к APIService.shared в основном потоке, это приведет к созданию CLLocationManager в основном потоке, и любые последующие доступы можно будет осуществлять из любого потока.

В код SwiftUI также необходимо внести несколько улучшений, например создание неструктурированного Task верхнего уровня, когда вместо этого можно использовать модификатор .task(id:), но это выходит за рамки данного вопроса.