当前位置：首页 > news >正文

c-线程创建，同步互斥，互斥锁；

news 来源：原创 2025/5/23 18:19:20

文章目录

案例描述1
- 代码实现
- 代码解释
案例背景2
- 代码实现
- 代码解析
- 关键概念总结
- 扩展练习

案例描述1

我们将模拟一个简单的售票系统，其中有两个售票窗口同时出售100张票。为了确保不会卖出超过100张票，并且不会出现卖票时的竞态条件（race condition），我们将使用互斥锁来保护共享资源——剩余票数。

代码实现

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

#define NUM_TICKETS 100
#define NUM_THREADS 2

int tickets = NUM_TICKETS;
pthread_mutex_t mutex;

void* sell_tickets(void* arg) {
    while (1) {
        pthread_mutex_lock(&mutex); // 获取互斥锁
        
        if (tickets > 0) {
            printf("Thread %ld sold ticket: %d\n", (long)arg, tickets);
            tickets--;
            pthread_mutex_unlock(&mutex); // 释放互斥锁
        } else {
            pthread_mutex_unlock(&mutex); // 释放互斥锁
            break; // 如果没有票了，退出循环
        }
        
        // 模拟线程间的切换，增加并发冲突的可能性
        // 可以通过注释掉下面这行代码来查看效果
        usleep(100); // 线程休眠100微秒
    }
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    
    // 初始化互斥锁
    if (pthread_mutex_init(&mutex, NULL) != 0) {
        printf("Mutex init failed\n");
        return -1;
    }

    // 创建两个线程
    for (int i = 0; i < NUM_THREADS; i++) {
        if (pthread_create(&threads[i], NULL, sell_tickets, (void*)(intptr_t)(i + 1)) != 0) {
            printf("Thread creation failed\n");
            return -1;
        }
    }

    // 等待所有线程完成
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    // 销毁互斥锁
    pthread_mutex_destroy(&mutex);

    printf("All tickets have been sold.\n");
    return 0;
}

代码解释

pthread_mutex_t mutex;：定义了一个互斥锁变量。
pthread_mutex_lock(&mutex); 和 pthread_mutex_unlock(&mutex);：分别用于获取和释放互斥锁。当一个线程获取到互斥锁后，其他试图获取同一互斥锁的线程将被阻塞，直到第一个线程释放该锁。
usleep(100);：让当前线程暂停一段时间，模拟线程间的时间片轮转，以便观察到并发冲突的情况。如果注释掉这一行，可能会减少并发冲突的机会，因为线程可能在执行完一次卖票操作前不会被打断。
pthread_create(&threads[i], NULL, sell_tickets, (void*)(intptr_t)(i + 1));：创建新线程并开始执行sell_tickets函数。

通过这个例子，您可以清楚地看到如何在线程之间安全地共享资源以及如何避免竞态条件。请注意，在实际应用中，需要根据具体情况调整互斥锁的应用范围，以最小化锁的粒度，从而提高程序的效率。
好的！我将通过一个详细的嵌入式案例，帮助你理解 线程创建、同步互斥和互斥锁 的概念。我们将使用 POSIX 线程（pthread）库 在 Linux 环境下实现，这是嵌入式开发中常用的多线程编程方法。

案例背景2

假设我们有一个嵌入式系统，需要同时采集传感器数据（如温度）和进行数据处理。为了避免数据竞争，我们需要：

创建两个线程：一个负责采集数据，另一个负责处理数据。
使用 互斥锁（Mutex） 保护共享数据（传感器数据）。

代码实现

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>  // 用于 sleep 函数

// 定义共享数据
int sensor_data = 0;

// 定义互斥锁
pthread_mutex_t mutex;

// 线程1：采集传感器数据
void *sensor_thread(void *arg) {
    while (1) {
        pthread_mutex_lock(&mutex);  // 加锁
        sensor_data++;               // 修改共享数据
        printf("Sensor采集数据: %d\n", sensor_data);
        pthread_mutex_unlock(&mutex);  // 解锁
        sleep(1);  // 模拟采集耗时
    }
    return NULL;
}

// 线程2：处理传感器数据
void *process_thread(void *arg) {
    while (1) {
        pthread_mutex_lock(&mutex);  // 加锁
        int data = sensor_data;     // 读取共享数据
        printf("Process处理数据: %d\n", data);
        pthread_mutex_unlock(&mutex);  // 解锁
        sleep(2);  // 模拟处理耗时
    }
    return NULL;
}

int main() {
    pthread_t tid1, tid2;

    // 初始化互斥锁
    pthread_mutex_init(&mutex, NULL);

    // 创建两个线程
    pthread_create(&tid1, NULL, sensor_thread, NULL);
    pthread_create(&tid2, NULL, process_thread, NULL);

    // 等待线程结束（实际中可能需要信号量控制）
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    // 销毁互斥锁
    pthread_mutex_destroy(&mutex);

    return 0;
}

代码解析

共享数据与互斥锁
- sensor_data 是共享的全局变量，会被两个线程同时访问。
- pthread_mutex_t mutex 定义了一个互斥锁，用于保护对 sensor_data 的访问。
线程函数
- sensor_thread：模拟传感器数据采集，每次对 sensor_data 加1。
- process_thread：模拟数据处理，读取 sensor_data 的值。
- 在访问共享数据前，通过 pthread_mutex_lock 加锁；操作完成后，通过 pthread_mutex_unlock 解锁。
主函数
- 初始化互斥锁 pthread_mutex_init。
- 创建两个线程 pthread_create。
- 等待线程结束 pthread_join（实际项目中可能需要更复杂的同步机制）。

关键概念总结

互斥锁（Mutex）
- 用于保护共享资源，确保同一时间只有一个线程访问。
- 操作：lock（加锁） → 临界区操作 → unlock（解锁）。
线程同步
- 通过互斥锁协调多个线程的执行顺序，避免数据竞争（Data Race）。
嵌入式场景注意事项
- 避免死锁：确保加锁后一定会解锁。
- 最小化临界区：减少锁的持有时间，提高系统实时性。