Swift多进程共享对象实现咨询：UART遥测设备多进程访问方案

一、跨进程"单例"的核心问题与可行方案 #

你的初始Swift单例是进程内唯一的，无法实现跨进程共享——每个进程有独立的地址空间，静态变量仅存在于当前进程内存中，其他进程完全无法访问。要实现多进程共享UART资源，必须依赖跨进程同步原语，而非普通单例模式，以下是两种贴合你需求的轻量方案：

方案1：文件锁+直接设备访问 #

UART设备文件（如/dev/tty0）支持多进程打开，但读写会交织混乱，因此可以通过跨进程文件锁实现序列化访问：

• 每个进程打开设备时，先获取独占锁（flock或fcntl），操作完成后释放锁
• 优先级调度可通过在用户层维护带优先级的请求队列，结合锁的等待逻辑实现：每个进程提交请求时标记优先级，获取锁后优先处理高优先级任务

方案2：共享内存+POSIX同步原语 #

通过共享内存存储优先级请求队列，搭配跨进程互斥锁/信号量实现同步：

1. 创建共享内存区域，存储按优先级排序的请求队列（如堆结构）
2. 用pthread_mutexattr_setpshared将互斥锁设置为跨进程共享，保护队列的读写
3. 每个进程可向队列添加请求，获取锁后按优先级顺序处理UART读写
4. UART设备句柄无法跨进程共享，因此每个进程需自行打开设备，通过锁保证同一时间只有一个进程操作设备

二、Swift实现示例（基于方案2） #

以下是适配跨进程场景的修改版代码，调用POSIX API实现跨进程同步：

import Foundation

class Telemetry {
    static let global = Telemetry()
    
    private let mutex: pthread_mutex_t
    private let ioHandler: IOHandler
    // 共享内存中的优先级请求队列（需额外实现共享内存管理逻辑）
    private var requestQueue: PriorityQueue<DataPackage>

    private init() {
        // 初始化跨进程互斥锁
        var attr = pthread_mutexattr_t()
        pthread_mutexattr_init(&attr)
        pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED)
        var mutex = pthread_mutex_t()
        pthread_mutex_init(&mutex, &attr)
        self.mutex = mutex
        
        self.ioHandler = IOHandler(port: "/dev/tty0")
        self.requestQueue = PriorityQueue() // 需基于共享内存实现
    }
    
    deinit {
        pthread_mutex_destroy(&mutex)
    }
    
    func send(data: DataPackage, clientID: UUID, priority: Int) {
        pthread_mutex_lock(&mutex)
        defer { pthread_mutex_unlock(&mutex) }
        
        // 将请求加入优先级队列
        requestQueue.enqueue(data, priority: priority)
        // 处理队列中最高优先级的请求
        if let topRequest = requestQueue.dequeue() {
            ioHandler.send(data: topRequest)
        }
    }
    
    func receive(clientID: UUID) -> DataPackage? {
        pthread_mutex_lock(&mutex)
        defer { pthread_mutex_unlock(&mutex) }
        
        guard let rawData = ioHandler.receive() else { return nil }
        return DataPackage(rawData: rawData, clientID: clientID)
    }
}

struct DataPackage {
    let rawData: Data
    let clientID: UUID
}

struct IOHandler {
    private let fileHandle: FileHandle?
    
    init(port: String) {
        self.fileHandle = try? FileHandle(forUpdatingAtPath: port)
        // 配置串口参数（波特率、数据位等，需调用POSIX的tcsetattr API）
        if let handle = fileHandle {
            var termios = termios()
            tcgetattr(handle.fileDescriptor, &termios)
            // 修改termios参数后调用tcsetattr
        }
    }
    
    func send(data: DataPackage) {
        fileHandle?.write(data.rawData)
    }
    
    func receive() -> Data? {
        return fileHandle?.readData(ofLength: 1024) // 按固定长度读取
    }
}

// 基于堆的优先级队列实现（需适配共享内存）
class PriorityQueue<Element> {
    private var elements: [(priority: Int, element: Element)] = []
    
    func enqueue(_ element: Element, priority: Int) {
        elements.append((priority, element))
        elements.sort { $0.priority > $1.priority }
    }
    
    func dequeue() -> Element? {
        return elements.removeFirst().element
    }
}

三、Swift是否适合该任务？ #

适合场景 #

• 若你或团队熟悉Swift，可直接使用：Swift可无缝调用所有POSIX API，性能接近C/C++，且内存安全特性能减少多进程同步的bug
• macOS/iOS环境下Swift系统集成度高，Linux环境也支持完整的POSIX调用

不适合场景 #

• 极端资源受限的嵌入式环境：Swift运行时会占用少量额外内存，相比C/C++内存开销更高
• 需大量使用传统C语言编写的UART/嵌入式库：虽可通过桥接层调用，但会增加开发成本

四、优先级调度的补充说明 #

若需严格的优先级保证，不能依赖操作系统进程调度，必须在用户层实现：

1. 所有发送请求先进入共享内存的优先级队列
2. 只有获取锁的进程有权从队列头部取出最高优先级请求处理
3. 接收逻辑可通过注册回调或信号通知机制，将数据分发到对应进程

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