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

IO进程练习：请在linux 利用c语言编程实现两个线程按照顺序依次输出”ABABABAB......“

article 2024/9/20 21:43:23

例如：a线程输出”A”之后b线程输出”B”，然后a线程输出“A”，再b线程输出”B”，之后往复循环。

【1】使用信号量实现

代码展示：

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

// 定义两个全局信号量，实现同步机制
sem_t sem0;
sem_t sem1;

void *handler_thread(void *arg)
{
    while (1)
    {
        // 由于 sem0 初值为 0,所以B线程刚开始申请不到资源，不会打印，等到A线程执行完释放 sem0 资源之后才能获得 sem0 资源
        sem_wait(&sem0); // P操作(申请资源), sem0--
        printf("B");     // 打印 B
        fflush(NULL);    // 强制刷新缓存区，不刷新缓存，B 将无法输出
        sleep(1);        // 睡眠 1 秒，实现B 输出后停顿 1 秒再释放 sem1 资源，A线程才能执行输出 A
        sem_post(&sem1); // V操作(释放资源) sem1++
    }
}

int main(int argc, char const *argv[])
{
    pthread_t tid;                  // 线程标识
    if (sem_init(&sem0, 0, 0) != 0) // 初始化信号量 sem0 初值为 0
    {
        perror("sem init 0 err");
        return -1;
    }

    if (sem_init(&sem1, 0, 1) != 0) // 初始化信号量 sem1 初值为 1
    {
        perror("sem init 1 err");
        return -1;
    }

    if (pthread_create(&tid, NULL, handler_thread, NULL) != 0) // 创建一个新的线程 handler_thread
    {
        perror("pthread err");
        return -1;
    }

    while (1)
    {
        // 因为我们要先打印 A 所以要让打印 A 的线程(A线程)刚开始就可以获得资源并执行
        // 所以让A线程申请 sem1 资源，sem1 初值为 1，可以直接申请资源成功，sem1--
        sem_wait(&sem1); // P 操作(申请资源)，sem1--，需要等待B线程释放资源后才能再次获得资源
        printf("A");     // 打印 A
        fflush(NULL);    // 强制刷新缓存区，不刷新缓存，A 将无法输出
        sleep(1);        // 睡眠 1 秒，实现A 输出后停顿 1 秒再输出 B
        // A 线程执行完之后，接下来需要执行 B 线程，但B 进程由于申请不到 sem0 资源而阻塞，所以A 线程执行完之后要释放 sem0 资源
        sem_post(&sem0); // V操作(释放资源)，sem0++
    }

    return 0;
}

运行结果：

【2】使用条件变量实现

注意：必须保证让pthread_cond_wait先执行，pthread_cond_signal再产生条件

代码展示：

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

pthread_mutex_t lock; // 互斥锁
pthread_cond_t cond;  // 条件变量

void *handler_A(void *arg) // A线程
{
    while (1)
    {
        sleep(1);                   // A 线程先睡眠 1 秒，目的是让 B 线程中的 条件等待语句先执行 pthread_cond_wait(&cond,&lock)
        pthread_mutex_lock(&lock);  // A 线程获得互斥锁，上锁
        printf("A");                // 打印 A
        fflush(NULL);               // 强制刷新缓存
        sleep(1);//睡眠 1 秒之后再产生条件，以实现间隔输出
        pthread_cond_signal(&cond); // 产生条件，不阻塞
        pthread_mutex_unlock(&lock);//解锁
    }

    return NULL;
}

void *handler_B(void *arg) // B线程
{
    while (1)
    {
        pthread_mutex_lock(&lock);//获得互斥锁，上锁
        pthread_cond_wait(&cond, &lock); // 阻塞，解锁，等待条件产生
        printf("B");//打印 B
        fflush(NULL);//强制刷新缓存区
        pthread_mutex_unlock(&lock);//开锁
    }

    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid1, tid2; // 两个线程标识

    pthread_cond_init(&cond, NULL); // 初始化条件变量

    if (pthread_mutex_init(&lock, NULL) != 0) // 初始化互斥锁
    {
        perror("lock err");
        return -1;
    }

    if (pthread_create(&tid1, NULL, handler_A, NULL) != 0) // 创建A线程
    {
        perror("phtread err");
        return -1;
    }

    if (pthread_create(&tid2, NULL, handler_B, NULL) != 0) // 创建B线程
    {
        perror("phtread err");
        return -1;
    }

    // 如果不加下面这两句，主线程main 会直接结束，return 0,两个从线程根本就不会执行，所以要阻塞，等待两个线程结束后，再结束主线程 main
    pthread_join(tid1, NULL); // 阻塞,等待指定的线程结束然后给其回收资源
    pthread_join(tid2, NULL); // 阻塞,等待指定的线程结束然后给其回收资源
    return 0;
}