IO线程-同步、互斥、条件变量

申屠武

已于 2024-07-04 19:30:14 修改

阅读量884

点赞数 22

CC 4.0 BY-SA版权

分类专栏： IO 文章标签：开发语言 linux

于 2024-07-03 20:45:23 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_67273669/article/details/140161618

IO 专栏收录该内容

28 篇文章

订阅专栏

1.同步

1.1概念

同步(synchronization)指的是多个任务(线程)按照约定的顺序相互配合完成一件事情

(异步：异步则反之，并非一定需要一件事做完再做另一件事。）

1.2同步机制

通过信号量实现线程间同步。

信号量：通过信号量实现同步操作；由信号量来决定线程是继续运行还是阻塞等待.

信号量代表某一类资源，其值表示系统中该资源的数量:

信号量的值>0,表示有资源可以用, 可以申请到资源,

信号量的值<=0, 表示没有资源可以通用, 无法申请到资源, 阻塞.

信号量还是一个受保护的变量，只能通过三种操作来访问：初始化、Ｐ操作(申请资源)、Ｖ操作(释放资源)

1.3函数接口

sem_t 信号量; 定义信号量

sem_init: 信号量初始化

sem_wait: 申请资源,P操作, 如果没有资源可以用, 阻塞, -1

sem_post: 释放资源,V操作, 非阻塞 +1

int sem_init( sem_t *sem, int pshared, unsignedint value)

功能：初始化信号量

参数：sem：初始化的信号量对象

pshared：信号量共享的范围( 0 : 线程间使用非0 :1进程间使用)

value：信号量初值

返回值：成功 0

失败 -1

int sem_wait( sem_t *sem)

功能：申请资源 P操作

参数：sem：信号量对象

返回值：成功 0

失败 -1

注：此函数执行过程，当信号量的值大于0时，表示有资源可以用，则继续执行，同时对信号量减1；当信号量的值等于0时，表示没有资源可以使用，函数阻塞

int sem_post( sem_t *sem)

功能：释放资源 V操作

参数：sem：信号量对象

返回值：成功 0

失败 -1

注：释放一次信号量的值加1，函数不阻塞

2.互斥

2.1概念

互斥：多个线程在访问临界资源时，同一时间只能一个线程访问

临界资源：一次仅允许一个线程所使用的资源

临界区：指的是一个访问共享资源的程序片段

互斥锁：通过互斥锁可以实现互斥机制，主要用来保护临界资源，每个临界资源都由一个互斥锁来保护，线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。如果无法获得锁，线程会阻塞直到获得锁为止。

2.2函数接口

pthread_mutex_t lock; // 申请锁

pthread_mutex_init； // 初始化锁

pthread_mutex_lock；// 上锁

pthread_mutex_unlock；// 解锁

int pthread_mutex_init( pthread_mutex_t *mutex, pthread_mutexattr_t *attr)

功能：初始化互斥锁

参数：mutex：互斥锁

attr: 互斥锁属性 // NULL表示缺省属性

返回值：成功 0

失败 -1

int pthread_mutex_lock( pthread_mutex_t *mutex)

功能：申请互斥锁

参数：mutex：互斥锁

返回值：成功 0

失败 -1、

注：和 pthread_mutex_trylock 区别：

pthread_mutex_lock 是阻塞的；

pthread_mutex_trylock 不阻塞，如果申请不到锁会立刻返回

int pthread_mutex_unlock( pthread_mutex_t *mutex)

功能：释放互斥锁

参数：mutex：互斥锁

返回值：成功 0

失败 -1

int pthread_mutex_destroy( pthread_mutex_t *mutex)

功能：销毁互斥锁

参数：mutex：互斥锁

2.3死锁

是指两个或两个以上的进程或线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

死锁产生的四个必要条件

1、互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用

2、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。

3、请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。

4、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

注意：当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

3.条件变量

条件变量用于在线程之间传递信号，以便某些线程可以等待某些条件发生。当某些条件发生时，条件变量会发出信号，使等待该条件的线程可以恢复执行。

一般和互斥锁搭配使用，实现同步机制:

pthread_cond_t cond; // 申请条件变量

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

使用前需要上锁：

pthread_mutex_lock(&lock); //上锁

判断条件

pthread_cond_wait(&cond, &lock); //阻塞等待条件产生，没有条件产生时阻塞，同时解锁，当条件产生时结束阻塞，再次上锁

pthread_cond_signal(&cond); //产生条件，不阻塞

pthread_cond_destroy(&cond); //销毁条件变量

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

4.练习一

通过线程实现数据的交互，主线程循环从终端输入，线程函数将数据循环输出，当输入quit结束程序。

4.1全局变量写法

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

char buf[32] = "";
int flag = 0;

// 定义全局变量，用于线程间通信
// 当flag为0时，调度到子线程，不运行，调度到 主线程时，进行输入并且flag 变为1
// 当flag为1时，调度到主线程，不运行，调度到 从线程时，进行输出并且flag 变为0

void *handler_thread(void *arg)
{
    while (1)
    {
        if (flag == 1)
        {
            // 当在主线程输入完之后，flag变为 1;
            // 满足从线程条件，当调度从线程时，就可以进行输出，
            // 输出完之后flag变为0，不满足从线程，满足主线程，调度到主线程时就进行输入
            if (strcmp(buf, "quit") == 0)
            {
                break;
            }
            printf("%s\n", buf);
            flag = 0;
        }
    }

    return NULL;
}

int main(int argc, char const *argv[])
{

    pthread_t tid;
    int n = pthread_create(&tid, NULL, handler_thread, NULL);
    if (n != 0)
    {
        perror(" creat thread error");
        return -1;
    }

    while (1)
    {
        if (flag == 0)
        {
            scanf("%s", buf);
            // 输入完之后，flag 改为1;不满足下次循环，
            // 只有当输出字符串之后，flag 变为 0 之后，满足 主线程条件，进行输入
            flag = 1;
            if (strcmp(buf, "quit") == 0)
            {
                break;
            }
        }
    }

    return 0;
}

4.2信号量写法

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

// 通过两个信号量,
// 当sem1为1时.从线程可以申请到资源进行输出,当sem1为0时进入阻塞,等待主线程输入
// 当sem2为1时,主线程可以进行输入,当sem2为0时进入阻塞,等待从线程进行输出

char buf[32] = "";
// 定义信号量
sem_t sem1;
sem_t sem2;

void *handler_thread(void *arg)
{
    while (1)
    {
        // 申请资源,sem1 为1时申请成功,之后sem1变为0;
        // sem1为0时申请失败进入阻塞
        sem_wait(&sem1);
        if (strcmp(buf, "quit") == 0)
        {
            break;
        }
        printf("%s\n", buf);
        // 输出完成,释放资源,sem2变为1,
        sem_post(&sem2);
    }

    return NULL;
}

int main(int argc, char const *argv[])
{
    // 初始化信号量
    if (sem_init(&sem1, 0, 0) != 0)
    {
        perror("sem1 init err");
        return -1;
    }

    if (sem_init(&sem2, 0, 1) != 0)
    {
        perror("sem init err");
        return -1;
    }

    pthread_t tid;
    int n = pthread_create(&tid, NULL, handler_thread, NULL);
    if (n != 0)
    {
        perror(" creat thread error");
        return -1;
    }

    while (1)
    {
        // 申请资源,sem2 为1时申请成功,之后sem2变为0;
        // sem1为0时申请失败进入阻塞
        sem_wait(&sem2);
        scanf("%s", buf);

        if (strcmp(buf, "quit") == 0)
        {
            break;
        }
        // 输出完成,释放资源,sem1变为1,
        sem_post(&sem1);
    }

    return 0;
}

5.练习二

请在linux 利用c语言编程实现两个线程按照顺序依次输出”ABABABAB......" (信雅达)

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

5.1信号量写法

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

// 利用信号量实现两个线程按照顺序一次输出ABABABAB

// 信号量
sem_t sem1;
sem_t sem2;

void *outa(void *arg)
{
    while (1)
    {
        sleep(1);
        // 申请资源，初始sem2信号量为1,a运行，
        // 输出A 之后，sem2 变为 0
        // 如果sem2为0, a阻塞
        sem_wait(&sem2);
        printf("A");
        // 输出A 之后，释放资源，sem1变为1
        sem_post(&sem1);
    }
}

void *outb(void *arg)
{
    while (1)
    {
        sleep(1);
        // 申请资源，初始sem1信号量为0,b阻塞，
        // 如果sem1为1, b运行
        // 输出完B 之后，sem1 变为
        sem_wait(&sem1);
        printf("B ");
        // 输出 B 之后，释放资源，sem2变为1
        sem_post(&sem2);
        putchar('\n');
    }
}

int main(int argc, char const *argv[])
{
    // 线程标识
    pthread_t tid1, tid2;
    // 初始化信号量
    sem_init(&sem1, 0, 0);
    sem_init(&sem2, 0, 1);
    // 创建线程并判断
    if (pthread_create(&tid1, NULL, outa, NULL) != 0)
    {
        perror("tid1 err");
        return -1;
    }
    if (pthread_create(&tid2, NULL, outb, NULL) != 0)
    {
        perror("tid2 err");
        return -1;
    }
    // 回收线程
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    return 0;
}

5.2互斥锁加条件变量写法

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

// 利用互斥所与条件变量实现两个线程按照顺序一次输出ABABABAB

// 定义全局条件变量与锁，条件变量用于线程间通信
pthread_mutex_t lock;
pthread_cond_t cond;

void *funA(void *arg)
{
    for (int i = 0; i < 10; i++)
    {
        sleep(2);
        pthread_mutex_lock(&lock); // 上锁
        printf("A");
        fflush(NULL);                // 刷新
        pthread_cond_signal(&cond);  // 发信号，此时线程b可以输出b
        pthread_mutex_unlock(&lock); // 解锁
    }

    pthread_exit(NULL);
}
void *funB(void *arg)
{
    for (int i = 0; i < 10; i++)
    {
        pthread_mutex_lock(&lock); // 上锁
        // 请求条件，没有条件时阻塞，等待线程a发出信号后，解除阻塞
        pthread_cond_wait(&cond, &lock);
        printf("B ");
        fflush(NULL);
        pthread_mutex_unlock(&lock);
    }
    putchar('\n');
    pthread_exit(NULL);
}

int main(int argc, char const *argv[])
{
    // 线程标识
    pthread_t tid1, tid2;
    // 初始化条件变量
    pthread_cond_init(&cond, NULL);

    // 创建线程
    if (pthread_create(&tid1, NULL, funA, NULL) < 0)
    {
        perror("tid1 err");
        return -1;
    }
    if (pthread_create(&tid2, NULL, funB, NULL) < 0)
    {
        perror("tid1 err");
        return -1;
    }

    // 初始化互斥锁
    pthread_mutex_init(&lock, NULL);
    // 判断互斥锁是否初始化成功
    if (pthread_mutex_init(&lock, NULL) != 0)
    {
        perror(" init error");
        return -1;
    }

    // 回收线程
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    return 0;
}