iOS线程优先级与QoS类深度解析

sylph mini

1. iOS线程优先级体系深度解析

在iOS开发中，线程优先级管理就像机场的航班调度系统。作为开发者，我们需要理解这套精密调度机制的工作原理，才能让关键任务获得及时响应，同时避免系统资源的滥用。

1.1 三层优先级架构

iOS的线程优先级并非简单的数字越大越快，而是由三个层次构成的完整体系：

QoS (Quality of Service)层 - 这是Apple官方推荐的方式。通过QoS类，你告诉系统任务的紧急程度，系统会根据设备状态智能调度。就像机场的值机柜台，你可以选择经济舱、商务舱或头等舱，但具体登机顺序还是由机场统一安排。

POSIX线程优先级层 - 这相当于试图直接跟登机口工作人员交涉。虽然在macOS上可能有效，但在iOS上常常被系统策略覆盖。就像在繁忙机场，单个工作人员很难为你打破整体登机规则。

Mach线程策略层 - 这是最底层的调度机制，相当于试图直接控制机场塔台。虽然功能强大，但普通App能获得的权限非常有限，滥用会导致各种问题。

1.2 QoS类的具体应用场景

理解每个QoS类的适用场景至关重要：

.userInteractive：用于必须立即完成的任务，如UI响应、动画计算。就像机场的VIP通道，只留给最紧急的乘客。
.userInitiated：用户明确等待结果的操作，如图片加载、页面打开。相当于商务舱，优先但不紧急。
.utility：可以稍后执行但需要持续运行的任务，如下载、导出。类似普通登机队列。
.background：完全不着急的任务，如数据预取、索引建立。就像红眼航班，系统会在资源充足时处理。

重要提示：在iOS 9之后，.default类实际上等同于.userInitiated，不再建议使用。明确指定QoS类能让系统更准确地理解你的意图。

2. 正确使用userInteractive类

2.1 创建高优先级队列的最佳实践

要让关键任务获得最高优先级，正确的方式是从源头设置QoS：

swift复制// 创建userInteractive队列的正确方式
let criticalQueue = DispatchQueue(
    label: "com.example.critical",
    qos: .userInteractive,
    attributes: [],
    autoreleaseFrequency: .workItem,
    target: nil
)

criticalQueue.async {
    // 这里执行关键任务
    self.processUserInput()
}

关键细节：

队列标签应包含反向域名，便于调试
对于串行队列，可以省略attributes参数
autoreleaseFrequency设置为.workItem可以优化内存使用
显式指定target为nil可以避免意外的优先级继承

2.2 OperationQueue的高优先级设置

对于基于Operation的任务系统：

swift复制let highPriorityOperationQueue = OperationQueue()
highPriorityOperationQueue.qualityOfService = .userInteractive

let criticalOperation = BlockOperation {
    // 关键任务代码
    self.prepareAnimationFrames()
}

// 设置操作本身的QoS（会覆盖队列的QoS）
criticalOperation.qualityOfService = .userInteractive

highPriorityOperationQueue.addOperation(criticalOperation)

经验之谈：

Operation的QoS会覆盖OperationQueue的QoS设置
对于复杂任务链，确保关键路径上的所有Operation都有正确的QoS
使用addOperations(_:waitUntilFinished:)可以确保操作间的依赖关系

2.3 QoS继承与传播机制

QoS的继承规则需要特别注意：

swift复制criticalQueue.async {
    // 这个block继承.userInteractive QoS
    
    DispatchQueue.global().async {
        // 这里会降级为.default QoS
        // 除非显式指定：
        DispatchQueue.global(qos: .userInteractive).async {
            // 保持高优先级
        }
    }
}

常见陷阱：

在userInteractive队列中调用未指定QoS的系统API可能导致优先级下降
使用DispatchGroup时，group的整体QoS由最后进入的任务决定
使用DispatchWorkItem时，可以显式设置qos参数来避免意外降级

3. Mach线程优先级的真相

3.1 Mach优先级数字的误解

坊间常说的"97+"优先级源于Mach内核的调度机制，但有几个关键事实常被忽视：

数字本身没有跨策略的统一含义。在TIMESHARE策略下，优先级范围是0-63；在FIXED策略下是0-127。
iOS对实时线程有严格限制。普通App能获得的最高优先级通常远低于真正的实时需求。
优先级数字只是调度的一个因素。CPU配额、线程策略、能量预算等都会影响最终调度。

3.2 可能的风险与限制

试图强行设置高Mach优先级可能导致：

看门狗超时：主线程被饿死导致应用被终止
音频卡顿：音频实时线程被干扰
发热降频：系统为控制温度主动降低CPU性能
电池快速耗尽：高优先级线程阻止CPU进入节能状态
审核被拒：滥用系统资源可能违反App Store指南

3.3 相对安全的Mach API使用

如果确实需要调整线程特性：

c复制#include <mach/thread_policy.h>

// 获取当前线程的Mach端口
thread_port_t thread = mach_thread_self();

// 设置时间约束策略
struct thread_time_constraint_policy policy;
policy.period = 100000;  // 周期
policy.computation = 50000; // 计算时间
policy.constraint = 80000; // 截止时间
policy.preemptible = TRUE; // 允许被抢占

thread_policy_set(thread,
                 THREAD_TIME_CONSTRAINT_POLICY,
                 (thread_policy_t)&policy,
                 THREAD_TIME_CONSTRAINT_POLICY_COUNT);

// 不要忘记释放端口
mach_port_deallocate(mach_task_self(), thread);

关键参数说明：

所有时间单位都是Mach绝对时间单位，需要使用mach_timebase_info转换
computation不应超过period的50%
设置preemptible为TRUE可以减少对其它线程的影响
这个策略最适合需要定期执行的实时任务，如音频处理

4. 系统认可的高性能通道

4.1 音频实时处理的最佳实践

对于真正的实时音频需求，应该使用Audio Unit的回调机制：

swift复制let audioComponentDescription = AudioComponentDescription(
    componentType: kAudioUnitType_Output,
    componentSubType: kAudioUnitSubType_RemoteIO,
    componentManufacturer: kAudioUnitManufacturer_Apple,
    componentFlags: 0,
    componentFlagsMask: 0)

AudioComponentInstanceNew(audioComponentDescription, &audioUnit)

// 设置渲染回调
var renderCallback = AURenderCallbackStruct(
    inputProc: renderCallbackFunction,
    inputProcRefCon: UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque()))

AudioUnitSetProperty(audioUnit,
                    kAudioUnitProperty_SetRenderCallback,
                    kAudioUnitScope_Input,
                    0,
                    &renderCallback,
                    UInt32(MemoryLayout<AURenderCallbackStruct>.size))

func renderCallbackFunction(
    inRefCon: UnsafeMutableRawPointer,
    ioActionFlags: UnsafeMutablePointer<AudioUnitRenderActionFlags>,
    inTimeStamp: UnsafePointer<AudioTimeStamp>,
    inBusNumber: UInt32,
    inNumberFrames: UInt32,
    ioData: UnsafeMutablePointer<AudioBufferList>?) -> OSStatus {
    
    // 在这里执行实时音频处理
    // 注意：不能分配内存、不能加锁、不能进行文件I/O
    
    return noErr
}

音频线程黄金法则：

保持回调函数执行时间短且稳定
避免任何内存分配操作
使用无锁数据结构与主线程通信
复杂处理应该预先计算好，回调只做简单混音

4.2 高性能图形渲染技巧

对于需要稳定帧率的图形应用：

swift复制let displayLink = CADisplayLink(target: self, selector: #selector(updateFrame))
displayLink.preferredFramesPerSecond = 60
displayLink.add(to: .current, forMode: .common)

@objc func updateFrame(displayLink: CADisplayLink) {
    // 在这里准备下一帧内容
    // 注意控制执行时间，确保不超过16ms(60fps)或8ms(120fps)
    
    let startTime = CACurrentMediaTime()
    
    prepareFrame()
    
    let elapsed = CACurrentMediaTime() - startTime
    if elapsed > 0.016 {
        print("警告：帧准备时间过长 \(elapsed * 1000)ms")
    }
}

性能优化要点：

使用Instruments的Core Animation和Metal System Trace工具分析渲染瓶颈
对于Metal应用，合理设置command buffer的提交策略
避免在渲染循环中分配内存或进行耗时的计算
考虑使用triple buffering减少帧延迟

5. 实战经验与避坑指南

5.1 userInteractive使用三大铁律

任务必须短小精悍：理想情况下不超过1-2毫秒。长时间任务应该分割成小块。

swift复制// 错误示范：在userInteractive队列执行耗时操作
criticalQueue.async {
    processLargeImage() // 可能耗时数百毫秒
}

// 正确做法：分割任务或降级处理
criticalQueue.async {
    beginImageProcessing() // 只做初始化
    DispatchQueue.global(qos: .userInitiated).async {
        processImageChunks() // 耗时部分在低优先级处理
        DispatchQueue.main.async {
            updateUIWithResults()
        }
    }
}

避免队列拥堵：串行队列上的长任务会阻塞后续任务。考虑使用多个专用队列。
优先级不是万能药：算法复杂度问题无法通过提高优先级解决。应该优化算法本身。

5.2 常见问题排查技巧

问题1：设置了高优先级但没效果

检查是否被系统策略覆盖（iOS可能会限制后台App的优先级提升）
使用Instruments的System Trace模板观察线程实际优先级
确认没有更高级别的系统任务占用CPU

问题2：提高优先级后出现卡顿

检查是否导致优先级反转（高优先级线程等待低优先级线程持有的锁）
使用os_signpost API标记关键代码段，便于性能分析
考虑使用无锁数据结构替代传统锁机制

问题3：音频出现爆音或卡顿

确保音频回调执行时间稳定
使用Mach绝对时间而不是NSDate进行时间计算
检查是否有内存分配操作导致停顿

5.3 Instruments分析技巧

Time Profiler：
- 勾选"Record Thread Priority"选项
- 观察线程优先级随时间变化
- 识别优先级反转情况
System Trace：
- 分析线程状态转换（运行、等待、阻塞）
- 查看线程优先级数值
- 识别调度器决策
Points of Interest：
- 使用os_signpost API标记关键阶段
- 分析任务时间分布
- 识别不合理的优先级分配

swift复制import os.signpost

let log = OSLog(subsystem: "com.example.app", category: .pointsOfInterest)

func criticalTask() {
    let signpostID = OSSignpostID(log: log)
    os_signpost(.begin, log: log, name: "Critical Task", signpostID: signpostID)
    
    // 执行关键任务
    
    os_signpost(.end, log: log, name: "Critical Task", signpostID: signpostID)
}

6. 性能优化综合策略

6.1 合理分配优先级

构建一个分层的任务优先级体系：

用户交互响应（.userInteractive）
- 触摸事件处理
- 动画计算
- 文本输入响应
用户请求任务（.userInitiated）
- 加载用户明确请求的内容
- 执行用户触发的操作
- 准备即将显示的数据
自动预加载（.utility）
- 预取可能需要的资源
- 后台数据处理
- 定期更新
维护性任务（.background）
- 日志上传
- 数据库整理
- 缓存清理

6.2 资源竞争管理

高优先级线程特别需要注意资源竞争：

swift复制// 使用无锁队列替代锁
let dataQueue = DispatchQueue(label: "com.example.data", 
                             qos: .userInteractive,
                             attributes: .concurrent)

func updateSharedData(_ newData: Data) {
    dataQueue.async(flags: .barrier) {
        // 独占写入
        sharedData = newData
    }
}

func readSharedData() -> Data {
    var result: Data!
    dataQueue.sync {
        // 并发读取
        result = sharedData
    }
    return result
}

优化技巧：

对于频繁读取、少量写入的数据，使用并发队列+barrier模式
考虑使用原子操作替代锁（如OSAtomic系列函数）
对于简单数据类型，可以考虑使用ThreadLocal存储

6.3 能量效率考量

高优先级线程对电池寿命的影响：

避免空转循环：

swift复制// 错误做法：忙等待
while !condition {
    // 空转消耗CPU
}

// 正确做法：使用事件驱动
let semaphore = DispatchSemaphore(value: 0)
func conditionChanged() {
    semaphore.signal()
}
semaphore.wait()

合理使用QoS类：非关键任务应该使用较低优先级
监控能量影响：
- 使用Energy Log工具测量功耗
- 关注thermal state变化
- 响应低电量模式

7. 调试与监控方案

7.1 线程状态监控

实时监控线程优先级变化：

swift复制import MachO

func monitorThreadPriority() {
    let thread = mach_thread_self()
    var info = thread_basic_info()
    var count = mach_msg_type_number_t(THREAD_BASIC_INFO_COUNT)
    
    let result = withUnsafeMutablePointer(to: &info) {
        $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
            thread_info(thread, THREAD_BASIC_INFO, $0, &count)
        }
    }
    
    if result == KERN_SUCCESS {
        print("线程调度策略: \(info.policy)")
        print("基础优先级: \(info.base_priority)")
        print("当前优先级: \(info.cur_priority)")
    }
    
    mach_port_deallocate(mach_task_self(), thread)
}

7.2 性能指标收集

构建自定义性能监控系统：

swift复制class PerformanceMonitor {
    private var samples: [CFAbsoluteTime] = []
    private let maxSamples = 100
    private let warningThreshold: CFAbsoluteTime = 0.016 // 16ms
    
    func recordSample(_ duration: CFAbsoluteTime) {
        samples.append(duration)
        if samples.count > maxSamples {
            samples.removeFirst()
        }
        
        if duration > warningThreshold {
            print("性能警告：任务耗时 \(duration*1000)ms")
        }
    }
    
    func averageTime() -> CFAbsoluteTime {
        guard !samples.isEmpty else { return 0 }
        return samples.reduce(0, +) / Double(samples.count)
    }
}

// 使用示例
let monitor = PerformanceMonitor()
criticalQueue.async {
    let start = CFAbsoluteTimeGetCurrent()
    // 执行任务
    let end = CFAbsoluteTimeGetCurrent()
    monitor.recordSample(end - start)
}

7.3 自动化测试方案

构建优先级相关的单元测试：

swift复制func testCriticalTaskTiming() {
    let expectation = XCTestExpectation(description: "Critical task completes in time")
    
    let startTime = CACurrentMediaTime()
    criticalQueue.async {
        let elapsed = CACurrentMediaTime() - startTime
        XCTAssertLessThan(elapsed, 0.1, "关键任务启动延迟过长")
        
        // 执行任务
        
        let taskDuration = CACurrentMediaTime() - startTime
        XCTAssertLessThan(taskDuration, 0.05, "关键任务执行时间过长")
        
        expectation.fulfill()
    }
    
    wait(for: [expectation], timeout: 1.0)
}

8. 高级优化技巧

8.1 实时线程与CPU亲和性

对于真正需要确定性的任务，可以考虑设置CPU亲和性：

c复制#include <mach/mach.h>
#include <mach/thread_policy.h>

void setThreadAffinity(int cpuNumber) {
    thread_port_t thread = mach_thread_self();
    
    thread_affinity_policy_data_t policy;
    policy.affinity_tag = cpuNumber;
    
    thread_policy_set(thread,
                     THREAD_AFFINITY_POLICY,
                     (thread_policy_t)&policy,
                     THREAD_AFFINITY_POLICY_COUNT);
    
    mach_port_deallocate(mach_task_self(), thread);
}

注意事项：

iOS可能会限制或忽略亲和性设置
错误使用可能导致性能下降
需要针对不同设备进行测试（核心数量不同）

8.2 内存访问优化

高优先级线程的内存访问模式对性能影响很大：

预取关键数据：在任务开始前将需要的数据加载到缓存
避免缓存抖动：保持数据结构紧凑，减少指针跳转
使用非临时存储：对于只写一次的数据，使用特殊指令避免污染缓存

swift复制func processImageData(_ data: UnsafePointer<UInt8>, count: Int) {
    // 预取数据到缓存
    __builtin_prefetch(data, 0, 3) // 预取读，高时效性
    
    var results = [UInt8](repeating: 0, count: count)
    results.withUnsafeMutableBytes { buffer in
        // 处理数据
        for i in 0..<count {
            buffer[i] = data[i] // 简单示例
        }
    }
    
    // 如果results只使用一次，可以标记为non-temporal
    // (Swift中没有直接支持，需要调用特定CPU指令)
}

8.3 实时任务的电源管理

确保高优先级任务不会过度消耗电量：

响应thermal state变化：

swift复制NotificationCenter.default.addObserver(
    forName: ProcessInfo.thermalStateDidChangeNotification,
    object: nil,
    queue: nil) { _ in
        let state = ProcessInfo.processInfo.thermalState
        switch state {
        case .nominal:
            resumeFullPerformance()
        case .fair, .serious:
            reduceWorkload()
        case .critical:
            suspendNonCriticalTasks()
        @unknown default:
            break
        }
    }

响应低电量模式：

swift复制if ProcessInfo.processInfo.isLowPowerModeEnabled {
    // 降低帧率或关闭非必要功能
    adjustPerformanceForLowPower()
}

9. 架构设计建议

9.1 分层任务调度架构

设计一个合理的任务调度系统：

code复制┌───────────────────────┐
│      UI Layer         │ ← userInteractive
└──────────┬────────────┘
           │
┌──────────▼────────────┐
│   Service Layer       │ ← userInitiated
└──────────┬────────────┘
           │
┌──────────▼────────────┐
│   Background Layer    │ ← utility/background
└───────────────────────┘

实现要点：

每层有明确的QoS类定义
层间通信通过明确的接口
避免跨层直接调用

9.2 自适应优先级调整

根据系统状态动态调整任务优先级：

swift复制class AdaptiveTaskScheduler {
    private let criticalQueue = DispatchQueue(label: "critical", qos: .userInteractive)
    private let normalQueue = DispatchQueue(label: "normal", qos: .userInitiated)
    
    func scheduleTask(_ task: @escaping () -> Void, isCritical: Bool) {
        let targetQueue: DispatchQueue
        let actualCritical = isCritical && !ProcessInfo.processInfo.isLowPowerModeEnabled
        
        if actualCritical {
            targetQueue = criticalQueue
        } else {
            targetQueue = normalQueue
        }
        
        targetQueue.async(execute: task)
    }
}

9.3 任务取消与超时机制

确保高优先级任务不会无限期占用资源：

swift复制func executeWithTimeout(_ task: @escaping () -> Void, timeout: TimeInterval) {
    let workItem = DispatchWorkItem(block: task)
    
    criticalQueue.async(execute: workItem)
    
    // 设置超时
    DispatchQueue.global().asyncAfter(deadline: .now() + timeout) {
        if !workItem.isCancelled {
            workItem.cancel()
            print("任务超时被取消")
        }
    }
}

10. 实际案例分析

10.1 流畅滚动列表优化

问题场景：UITableView滚动时卡顿

解决方案：

将cell布局计算放在.userInteractive队列
图片解码放在.userInitiated队列
使用预取API提前准备数据

swift复制func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    let criticalQueue = DispatchQueue(label: "layout", qos: .userInteractive)
    
    criticalQueue.async {
        // 关键布局计算
        let size = calculateCellSize(for: data[indexPath.row])
        
        DispatchQueue.main.async {
            // 更新UI必须在主线程
            cell.frame.size = size
        }
    }
    
    let imageQueue = DispatchQueue(label: "image", qos: .userInitiated)
    imageQueue.async {
        // 图片解码
        let image = decodeImage(for: data[indexPath.row])
        
        DispatchQueue.main.async {
            cell.imageView?.image = image
        }
    }
}

10.2 实时音频处理优化

问题场景：音频回调偶尔出现卡顿

解决方案：

确保回调函数执行时间短且稳定
使用无锁环形缓冲区与主线程通信
复杂处理移到低优先级线程

swift复制// 无锁环形缓冲区实现
class RingBuffer {
    private var buffer: [Float]
    private var readPos = 0
    private var writePos = 0
    private let size: Int
    
    init(size: Int) {
        self.size = size
        self.buffer = [Float](repeating: 0, count: size)
    }
    
    func write(_ data: [Float]) -> Bool {
        // 实现原子写入逻辑
        // ...
    }
    
    func read(count: Int) -> [Float]? {
        // 实现原子读取逻辑
        // ...
    }
}

// 音频回调
func renderCallback(...) -> OSStatus {
    // 从环形缓冲区获取预处理好的音频数据
    if let samples = ringBuffer.read(count: Int(inNumberFrames)) {
        // 填充音频缓冲区
        // ...
    } else {
        // 数据不足，生成静音
        // ...
    }
    
    // 异步触发下一次处理
    DispatchQueue.global(qos: .utility).async {
        processNextAudioChunk()
    }
    
    return noErr
}

10.3 游戏主循环优化

问题场景：游戏帧率不稳定

解决方案：

将游戏循环分为固定时间步长
高优先级处理输入和关键逻辑
低优先级处理非关键更新

swift复制func gameLoop() {
    let criticalQueue = DispatchQueue(label: "game.critical", qos: .userInteractive)
    let normalQueue = DispatchQueue(label: "game.normal", qos: .userInitiated)
    
    var lastTime = CACurrentMediaTime()
    
    func frame() {
        let currentTime = CACurrentMediaTime()
        let deltaTime = currentTime - lastTime
        lastTime = currentTime
        
        // 关键逻辑在高优先级队列
        criticalQueue.async {
            processInput(deltaTime)
            updatePhysics(deltaTime)
        }
        
        // 非关键逻辑在普通队列
        normalQueue.async {
            updateAI(deltaTime)
            updateNonCriticalSystems(deltaTime)
        }
        
        // 渲染总是在主线程
        DispatchQueue.main.async {
            renderFrame()
        }
        
        // 下一帧
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.016) {
            frame()
        }
    }
    
    frame()
}

11. 工具链与生态系统

11.1 性能分析工具推荐

Instruments：
- Time Profiler：CPU使用分析
- System Trace：线程调度分析
- Core Animation：渲染性能
- Metal System Trace：GPU分析
Xcode调试工具：
- View Debugger：界面层级分析
- Memory Debugger：内存使用分析
- Thread Sanitizer：线程问题检测
第三方工具：
- Flex：运行时界面调试
- Netfox：网络请求监控
- Pulse：日志记录与分析

11.2 实用调试技巧

打印当前线程信息：

swift复制func printThreadInfo() {
    let thread = mach_thread_self()
    var info = thread_identifier_info()
    var count = mach_msg_type_number_t(THREAD_IDENTIFIER_INFO_COUNT)
    
    let result = withUnsafeMutablePointer(to: &info) {
        $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
            thread_info(thread, THREAD_IDENTIFIER_INFO, $0, &count)
        }
    }
    
    if result == KERN_SUCCESS {
        print("线程ID: \(info.thread_id)")
        print("调度策略: \(info.dispatch_qos_class)")
    }
    
    mach_port_deallocate(mach_task_self(), thread)
}

测量代码块执行时间：

swift复制func measure<T>(_ label: String, _ block: () -> T) -> T {
    let start = mach_absolute_time()
    let result = block()
    let end = mach_absolute_time()
    
    var timebase = mach_timebase_info()
    mach_timebase_info(&timebase)
    
    let elapsed = (end - start) * UInt64(timebase.numer) / UInt64(timebase.denom)
    print("\(label)耗时: \(elapsed / 1_000_000)ms")
    
    return result
}

// 使用示例
let result = measure("关键计算") {
    performCriticalCalculation()
}

11.3 构建监控系统

实现简单的性能监控看板：

swift复制class PerformanceDashboard {
    static let shared = PerformanceDashboard()
    
    private var metrics: [String: (sum: Double, count: Int)] = [:]
    private let queue = DispatchQueue(label: "metrics", qos: .utility)
    
    func recordMetric(_ name: String, value: Double) {
        queue.async {
            if let existing = self.metrics[name] {
                self.metrics[name] = (existing.sum + value, existing.count + 1)
            } else {
                self.metrics[name] = (value, 1)
            }
        }
    }
    
    func printReport() {
        queue.sync {
            print("===== 性能报告 =====")
            for (name, data) in metrics {
                let avg = data.sum / Double(data.count)
                print("\(name): 平均值 \(avg*1000)ms (样本数 \(data.count))")
            }
        }
    }
}

// 使用示例
func criticalTask() {
    let start = CACurrentMediaTime()
    // 执行任务
    let end = CACurrentMediaTime()
    PerformanceDashboard.shared.recordMetric("关键任务", value: end - start)
}

12. 未来趋势与演进

12.1 Swift并发模型的优先级处理

随着Swift并发模型的普及，理解其与QoS的交互很重要：

swift复制func performCriticalWork() async {
    // 明确指定任务优先级
    await withTaskGroup(of: Void.self) { group in
        group.addTask(priority: .userInitiated) {
            await loadResource()
        }
        
        group.addTask(priority: .userInteractive) {
            await processUserInput()
        }
    }
}

// 在UIKit环境中使用
@MainActor func updateUI() async {
    // 主actor自动运行在主线程
    let data = await fetchData() // 会自动继承调用方的优先级
    tableView.reloadData()
}

注意事项：

Swift并发任务会继承创建时的优先级
使用Task(priority:)可以显式设置优先级
主actor上的操作总是在主线程执行

12.2 多核调度优化

随着iOS设备核心数增加，考虑线程亲和性：

swift复制func setThreadAffinity(cpuMask: UInt64) -> Bool {
    let THREAD_AFFINITY_POLICY_COUNT = mach_msg_type_number_t(
        MemoryLayout<thread_affinity_policy>.size / MemoryLayout<integer_t>.size)
    
    var policy = thread_affinity_policy()
    policy.affinity_tag = cpuMask
    
    let result = withUnsafeMutablePointer(to: &policy) {
        $0.withMemoryRebound(to: integer_t.self, capacity: Int(THREAD_AFFINITY_POLICY_COUNT)) {
            thread_policy_set(mach_thread_self(), THREAD_AFFINITY_POLICY, $0, THREAD_AFFINITY_POLICY_COUNT)
        }
    }
    
    return result == KERN_SUCCESS
}

// 使用示例：将线程绑定到性能核心
_ = setThreadAffinity(cpuMask: 0b1100) // 假设核心2和3是性能核心

12.3 机器学习任务优化

对于ML任务，合理设置优先级：

swift复制func runMLTask() {
    // 预处理在用户交互优先级
    DispatchQueue.global(qos: .userInteractive).async {
        let input = preprocessInput()
        
        // 实际推理在实用优先级
        DispatchQueue.global(qos: .utility).async {
            let result = try? mlModel.prediction(input: input)
            
            // 结果处理回用户交互优先级
            DispatchQueue.global(qos: .userInteractive).async {
                handleResult(result)
            }
        }
    }
}