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

1.同步

1.1概念

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

(异步:异步则反之,并非一定需要一件事做完再做另一件事。)

1.2同步机制

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

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

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

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

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

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

 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;
}

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值