【漫谈C语言和嵌入式019】并发编程的艺术：嵌入式系统中的多线程与同步机制

最新推荐文章于 2024-10-24 18:17:44 发布

Seraphina_Lily

最新推荐文章于 2024-10-24 18:17:44 发布

阅读量808

点赞数 20

分类专栏：漫谈C语言和嵌入式文章标签： c语言开发语言并发编程

本文链接：https://blog.csdn.net/2403_83044722/article/details/141354327

版权

漫谈C语言和嵌入式专栏收录该内容

63 篇文章 6 订阅

订阅专栏

在嵌入式系统中，并发编程是一个至关重要的主题。无论是在实时操作系统（RTOS）中实现任务调度，还是在多核处理器上高效利用资源，并发编程都是不可回避的核心技术。然而，并发编程并非易事，稍有不慎就可能导致资源竞争、死锁等棘手问题。本文将深入探讨嵌入式系统中的并发编程，并通过具体的代码示例展示如何在 C 语言中实现多线程与同步机制。

一、并发编程的基本概念

并发编程是一种程序设计范式，允许多个任务或线程同时执行，以提高系统的响应性和资源利用率。典型的并发编程模式包括多线程、多进程和异步编程。在嵌入式系统中，多线程编程是最常用的并发方式，通常通过线程调度器管理线程的执行。

线程：线程是比进程更小的执行单元，一个进程可以包含多个线程。线程共享进程的内存空间和资源，这使得线程间通信比进程间通信更加高效。
同步机制：由于线程之间共享资源，为了避免资源竞争和数据不一致，通常需要引入同步机制，如互斥锁、信号量和条件变量。

二、线程的创建与管理

在 C 语言中，POSIX 线程（pthread）库是实现多线程编程的常用工具。下面的代码展示了如何在嵌入式系统中创建和管理线程。

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

void* thread_function(void* arg) {
    int* id = (int*)arg;
    for (int i = 0; i < 5; i++) {
        printf("Thread %d is running\n", *id);
        sleep(1);
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    int id1 = 1, id2 = 2;

    // 创建线程
    pthread_create(&thread1, NULL, thread_function, &id1);
    pthread_create(&thread2, NULL, thread_function, &id2);

    // 等待线程结束
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    printf("All threads finished.\n");

    return 0;
}

/*
示例运行结果：
Thread 1 is running
Thread 2 is running
Thread 1 is running
Thread 2 is running
Thread 1 is running
Thread 2 is running
Thread 1 is running
Thread 2 is running
Thread 1 is running
Thread 2 is running
All threads finished.
*/

在这个示例中，我们创建了两个线程，每个线程都会打印它的 ID 并运行五次。使用 pthread_create 创建线程，使用 pthread_join 等待线程结束。通过这种方式，我们可以在嵌入式系统中实现简单的并发任务。

三、资源竞争与互斥锁

在多线程环境中，多个线程可能会同时访问共享资源，这可能导致资源竞争和数据不一致问题。互斥锁（mutex）是一种常见的同步机制，用于确保同一时刻只有一个线程可以访问共享资源。

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

pthread_mutex_t mutex;
int shared_counter = 0;

void* increment_counter(void* arg) {
    for (int i = 0; i < 10000; i++) {
        pthread_mutex_lock(&mutex);  // 加锁
        shared_counter++;
        pthread_mutex_unlock(&mutex);  // 解锁
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

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

    // 创建线程
    pthread_create(&thread1, NULL, increment_counter, NULL);
    pthread_create(&thread2, NULL, increment_counter, NULL);

    // 等待线程结束
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

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

    printf("Final counter value: %d\n", shared_counter);

    return 0;
}

/*
示例运行结果：
Final counter value: 20000
*/

在这个示例中，两个线程同时递增共享计数器 shared_counter。为了避免竞争条件，我们使用了互斥锁 pthread_mutex_lock 和 pthread_mutex_unlock 来保护共享资源。在所有线程执行完毕后，最终的计数器值为预期的 20000，这证明了互斥锁的有效性。

四、信号量与线程同步

信号量（semaphore）是一种更高级的同步机制，除了用于互斥锁定，还可以用于管理多线程之间的同步和资源分配。在嵌入式系统中，信号量通常用于控制线程对有限资源的访问。

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

sem_t semaphore;

void* worker(void* arg) {
    int id = *(int*)arg;
    
    sem_wait(&semaphore);  // 等待信号量
    printf("Worker %d: Entering critical section\n", id);
    sleep(2);  // 模拟工作
    printf("Worker %d: Leaving critical section\n", id);
    sem_post(&semaphore);  // 释放信号量
    
    return NULL;
}

int main() {
    pthread_t thread1, thread2, thread3;
    int id1 = 1, id2 = 2, id3 = 3;

    // 初始化信号量，允许同时一个线程进入临界区
    sem_init(&semaphore, 0, 1);

    // 创建线程
    pthread_create(&thread1, NULL, worker, &id1);
    pthread_create(&thread2, NULL, worker, &id2);
    pthread_create(&thread3, NULL, worker, &id3);

    // 等待线程结束
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_join(thread3, NULL);

    // 销毁信号量
    sem_destroy(&semaphore);

    return 0;
}

/*
示例运行结果：
Worker 1: Entering critical section
Worker 1: Leaving critical section
Worker 2: Entering critical section
Worker 2: Leaving critical section
Worker 3: Entering critical section
Worker 3: Leaving critical section
*/

在这个示例中，我们使用信号量 sem_t 来控制最多同时一个线程进入临界区。信号量的初始值为 1，这意味着只有一个线程能够进入临界区，其余线程必须等待。通过这种方式，我们可以实现线程之间的同步，防止资源竞争。