Swift并发中MainActor使用疑惑：CoreLocation主线程调用问题

问题背景 #

需要解决CoreLocation的requestLocation方法必须在主线程执行的问题，通过多个测试案例发现不同调用方式存在差异，需明确Swift并发中主线程的遵循规则并修复Test5的运行问题。

最小可复现代码 #

import CoreLocation
import MapKit
import SwiftUI

struct ContentView: View {
    var locationManager = LocationManager()

    var body: some View {
        Button {
            Task {
                let location = try await locationManager.currentLocation // works
                print(location)
                let location2 = try await locationManager.work() // works, no mainactor needed
                print(location2)
                 let location3 = try await APIService.shared.test() // doesnt work
                print(location3)
                let location4 = try await APIService.shared.test2() // works, mainactor needed
                print(location4)
                let location5 = try await APIService.shared.test3() // doesnt work even with mainactor
                print(location5)
            }
        } label: {
            Text("Get Location")
        }.task {
            // 1. Check if the app is authorized to access the location services of the device
            locationManager.checkAuthorization()
        }
    }
}

class LocationManager: NSObject, CLLocationManagerDelegate {
    // MARK: Object to Access Location Services

    private let locationManager = CLLocationManager()

    // MARK: Set up the Location Manager Delegate

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

    // MARK: Request Authorization to access the User Location

    func checkAuthorization() {
        switch locationManager.authorizationStatus {
        case .notDetermined:
            locationManager.requestWhenInUseAuthorization()
        default:
            return
        }
    }

    // MARK: Continuation Object for the User Location

    private var continuation: CheckedContinuation<CLLocation, Error>?

    // MARK: Async Request the Current Location

    var currentLocation: CLLocation {
        get async throws {
            return try await withCheckedThrowingContinuation { continuation in
                // 1. Set up the continuation object
                self.continuation = continuation
                // 2. Triggers the update of the current location
                locationManager.requestLocation()
            }
        }
    }

    @MainActor
    var currentLocation2: CLLocation {
        get async throws {
            return try await withCheckedThrowingContinuation { continuation in
                // 1. Set up the continuation object
                self.continuation = continuation
                // 2. Triggers the update of the current location
                locationManager.requestLocation()
            }
        }
    }

    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        // 4. If there is a location available
        if let lastLocation = locations.last {
            // 5. Resumes the continuation object with the user location as result
            continuation?.resume(returning: lastLocation)
            // Resets the continuation object
            continuation = nil
        }
    }

    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
        // 6. If not possible to retrieve a location, resumes with an error
        continuation?.resume(throwing: error)
        // Resets the continuation object
        continuation = nil
    }

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

class APIService {
    static let shared = APIService()

    // Private initializer to prevent the creation of additional instances
    private init() {
    }

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

    @MainActor
    func test2() async throws -> String {
        return try await String(describing: LocationManager().currentLocation)
    }

    func test3() async throws -> String {
        return try await String(describing: LocationManager().currentLocation2)
    }
}

测试结果分析 #

• Test1（locationManager.currentLocation）：正常工作。SwiftUI的Button Action闭包默认运行在@MainActor上下文，内部启动的Task继承了该上下文，因此requestLocation在主线程执行。
• Test2（locationManager.work()）：正常工作。work方法调用currentLocation时，继承了调用者的@MainActor上下文，无需额外标注。
• Test3（APIService.shared.test()）：无法运行。test方法未标注@MainActor，调用时默认在后台线程执行，创建LocationManager实例并调用currentLocation时，requestLocation不在主线程，违反CoreLocation要求。
• Test4（APIService.shared.test2()）：正常工作。test2标注了@MainActor，强制整个方法在主线程执行，requestLocation符合线程要求。
• Test5（APIService.shared.test3()）：无法运行。虽然currentLocation2标注了@MainActor，但test3方法在非主线程上下文执行，创建LocationManager实例时未绑定到@MainActor，调用currentLocation2时无法自动切换到主线程。

Swift并发主线程核心规则 #

1. 上下文继承：异步任务默认继承调用者的Actor上下文。SwiftUI的View、Button Action、.task修饰器等默认运行在@MainActor上，内部启动的Task会自动继承该上下文。
2. 显式Actor约束：用@MainActor标记类、方法或属性时，意味着这些成员必须在主线程执行。但调用这些成员时，需要确保调用点的上下文能切换到@MainActor，否则会导致线程违规。
3. 实例与Actor绑定：对于标记了@MainActor的属性，只有当所属实例是在@MainActor上下文创建或访问时，属性的getter才会自动在主线程执行。如果实例在非主线程创建，即使属性标注了@MainActor，调用时也需要显式切换上下文。

Test5问题修复方案 #

方案一：给test3添加@MainActor标注 #

确保整个方法在主线程执行，创建LocationManager实例和调用currentLocation2都在主线程：

@MainActor
func test3() async throws -> String {
    return try await String(describing: LocationManager().currentLocation2)
}

方案二：显式切换到@MainActor上下文调用 #

即使test3不在主线程执行，通过MainActor.run强制切换上下文：

func test3() async throws -> String {
    return try await String(describing: await MainActor.run {
        try await LocationManager().currentLocation2
    })
}

更规范的根源解决方案 #

给LocationManager整个类标注@MainActor，因为它依赖的CLLocationManager必须在主线程操作，确保所有成员默认在主线程执行，避免遗漏：

@MainActor
class LocationManager: NSObject, CLLocationManagerDelegate {
    // ... 原有代码保持不变
}

这样无论在哪里创建LocationManager实例，调用它的方法或属性时都会自动切换到@MainActor上下文，彻底避免线程违规问题。

内容的提问来源于stack exchange，提问作者erotsppa