3. QNX进程与线程：进程模型、线程创建与管理、同步机制

好，咱们进入第三章。这一章我打算聊聊QNX里最核心的两个概念——进程和线程。说实话，很多做嵌入式开发的朋友，在Linux上玩得很溜，一到QNX就有点懵。为什么？因为QNX的进程模型和线程调度，跟Linux有挺大区别的。我个人习惯是，先搞懂底层模型，再动手写代码，这样踩坑的概率会小很多。

3.1 进程模型：微内核下的“轻量级”进程

QNX是微内核架构，这点跟Linux的宏内核完全不同。微内核意味着什么？说白了，内核只做最核心的事——进程调度、IPC（进程间通信）、中断处理。其他的，比如文件系统、设备驱动，统统跑在用户空间。

所以QNX的进程，其实比Linux的进程要“轻”一些。每个进程有自己的地址空间，但进程间通信（Message Passing）是QNX的看家本领。我刚开始接触QNX时，总觉得进程间通信很麻烦，后来才发现，这种设计让系统异常稳定——一个驱动挂了，不会把整个系统拖垮。

创建进程，最常用的就是fork()和exec()。不过QNX里还有个spawn()，我个人更推荐用这个。为什么？因为spawn()一步到位，直接创建并加载新程序，省去了fork()后还要exec()的麻烦。

// 使用 spawn() 创建进程
#include <spawn.h>
#include <sys/neutrino.h>

int main() {
    pid_t pid;
    char *argv[] = {"/usr/bin/my_driver", "-d", NULL};
    
    // 设置进程优先级和调度策略
    struct sched_param param;
    param.sched_priority = 20;  // 优先级范围 0-255
    
    // 创建进程
    pid = spawn("/usr/bin/my_driver", 0, NULL, NULL, argv, NULL);
    if (pid == -1) {
        perror("spawn failed");
        return EXIT_FAILURE;
    }
    
    printf("Driver process created, PID: %d\n", pid);
    return EXIT_SUCCESS;
}

嗯，这里要注意：spawn()的最后一个参数是环境变量，如果传NULL，子进程会继承父进程的环境。我在项目中遇到过，因为环境变量没传对，导致驱动加载时找不到配置文件，折腾了半天。

3.2 线程创建与管理：Pthreads的QNX风味

线程是调度的最小单位。QNX的线程模型完全符合POSIX标准，所以如果你写过Linux下的pthread，上手会很快。但QNX有一些自己的“小脾气”。

创建线程用pthread_create()，这个大家都熟。但QNX里，线程的优先级和调度策略是重中之重。为什么？因为QNX是硬实时系统，线程优先级决定了谁能抢到CPU。

#include <pthread.h>
#include <sched.h>

void *driver_thread(void *arg) {
    // 线程工作循环
    while (1) {
        // 处理中断或I/O
        printf("Driver thread running...\n");
        sleep(1);
    }
    return NULL;
}

int main() {
    pthread_t tid;
    struct sched_param param;
    
    // 设置线程为FIFO调度策略，优先级50
    param.sched_priority = 50;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
    pthread_attr_setschedparam(&attr, ¶m);
    
    // 创建线程
    if (pthread_create(&tid, &attr, driver_thread, NULL) != 0) {
        perror("pthread_create failed");
        return EXIT_FAILURE;
    }
    
    // 等待线程结束（本例中不会结束）
    pthread_join(tid, NULL);
    return EXIT_SUCCESS;
}

线程管理还包括pthread_cancel()、pthread_detach()等。我建议，驱动线程最好设为detach状态，这样线程结束后自动释放资源，省得你还要去join。

3.3 同步机制：Mutex与Condvar

多线程编程，最头疼的就是同步。QNX提供了标准的POSIX同步原语：Mutex（互斥锁）和Condvar（条件变量）。

3.3.1 Mutex：保护共享资源

Mutex说白了就是一把锁。谁拿到锁，谁就能访问共享资源。QNX的Mutex支持递归锁和优先级继承，这点对实时系统特别重要。

#include <pthread.h>

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int shared_data = 0;

void *writer_thread(void *arg) {
    pthread_mutex_lock(&lock);
    shared_data = 42;  // 写共享数据
    printf("Writer: set data to %d\n", shared_data);
    pthread_mutex_unlock(&lock);
    return NULL;
}

void *reader_thread(void *arg) {
    pthread_mutex_lock(&lock);
    printf("Reader: read data %d\n", shared_data);
    pthread_mutex_unlock(&lock);
    return NULL;
}

3.3.2 Condvar：等待条件满足

条件变量通常和Mutex配合使用。它的作用是：让线程等待某个条件成立，而不是忙等待（busy waiting）。

#include <pthread.h>

pthread_mutex_t cond_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int data_ready = 0;

void *producer(void *arg) {
    // 生产数据
    pthread_mutex_lock(&cond_lock);
    data_ready = 1;
    printf("Producer: data is ready\n");
    pthread_cond_signal(&cond);  // 唤醒等待的消费者
    pthread_mutex_unlock(&cond_lock);
    return NULL;
}

void *consumer(void *arg) {
    pthread_mutex_lock(&cond_lock);
    while (data_ready == 0) {
        pthread_cond_wait(&cond, &cond_lock);  // 等待条件
    }
    printf("Consumer: got data\n");
    pthread_mutex_unlock(&cond_lock);
    return NULL;
}

这里有个细节：pthread_cond_wait()会原子性地释放Mutex并进入等待，被唤醒后又会重新获取Mutex。你想想看，如果不用条件变量，消费者就得一直轮询data_ready，CPU占用率直接拉满。

3.4 同步机制的高级用法：优先级继承与死锁预防

在实时系统中，优先级反转是个大问题。什么叫优先级反转？就是一个高优先级线程，被一个低优先级线程持有的锁给阻塞了。QNX的Mutex支持优先级继承协议，能有效缓解这个问题。

同步机制	适用场景	注意事项
普通Mutex	短时间临界区	可能引发优先级反转
递归Mutex	同一线程多次加锁	性能略低于普通Mutex
条件变量	等待特定条件	必须配合Mutex使用
信号量	资源计数	QNX中不常用，推荐Mutex+Condvar

我记得有一次，一个同事在驱动里用了信号量做同步，结果高优先级的中断线程被低优先级的处理线程阻塞了，整个系统的响应时间从微秒级掉到了毫秒级。后来换成带优先级继承的Mutex，问题立刻解决。

3.5 实战：一个简单的驱动线程框架

最后，我给大家一个驱动线程的框架示例。这个框架包含了线程创建、Mutex保护、条件变量通知，基本覆盖了本章的核心内容。

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    pthread_t tid;
    pthread_mutex_t lock;
    pthread_cond_t cond;
    int running;
    int data;
} driver_t;

void *driver_loop(void *arg) {
    driver_t *drv = (driver_t *)arg;
    
    while (drv->running) {
        pthread_mutex_lock(&drv->lock);
        // 等待数据或中断
        pthread_cond_wait(&drv->cond, &drv->lock);
        
        // 处理数据
        printf("Processing data: %d\n", drv->data);
        
        pthread_mutex_unlock(&drv->lock);
    }
    return NULL;
}

int main() {
    driver_t drv;
    drv.running = 1;
    
    pthread_mutex_init(&drv.lock, NULL);
    pthread_cond_init(&drv.cond, NULL);
    
    // 创建驱动线程，优先级设为40
    pthread_attr_t attr;
    struct sched_param param;
    param.sched_priority = 40;
    pthread_attr_init(&attr);
    pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
    pthread_attr_setschedparam(&attr, ¶m);
    
    pthread_create(&drv.tid, &attr, driver_loop, &drv);
    
    // 模拟外部事件
    sleep(2);
    pthread_mutex_lock(&drv.lock);
    drv.data = 100;
    pthread_cond_signal(&drv.cond);
    pthread_mutex_unlock(&drv.lock);
    
    // 清理
    sleep(1);
    drv.running = 0;
    pthread_join(drv.tid, NULL);
    pthread_mutex_destroy(&drv.lock);
    pthread_cond_destroy(&drv.cond);
    
    return 0;
}

嗯，这个框架虽然简单，但已经能应对大部分驱动场景了。你想想看，实际项目中无非就是在这个框架上增加中断处理、DMA传输、设备寄存器操作等。核心的线程管理和同步逻辑，基本不变。

好，第三章就到这里。下一章我会讲QNX的中断处理与ISR设计，那才是驱动开发的硬核部分。到时候咱们再聊。