Liunx高级系统设计9-线程间同步与互斥

最新推荐文章于 2024-09-12 20:58:18 发布
最新推荐文章于 2024-09-12 20:58:18 发布
阅读量975 收藏 23
点赞数 28
分类专栏： Linux高级系统编程 文章标签： linux c语言 C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50963877/article/details/134979812
版权

同步与互斥的概念

互斥：同一时间，只能有一个任务（进程或线程）执行，谁先执行不确定。
同步：同一时间，只能有一个任务（进程或线程）执行，有顺序的执行。
同步 是特殊的互斥。

锁（互斥锁）

作用：又名互斥锁,让多个线程时,保证同时只能有一个线程执行任务

用于线程的互斥。
互斥锁是一种简单的加锁的方法来控制对共享资源的访问。
互斥锁只有两种状态 , 即加锁 ( lock ) 和解锁（ unlock ）。
操作原理：
        1）在访问共享资源后临界区域前，对互斥锁进行加锁。
        2）在访问完成后释放互斥锁导上的锁。
        3）对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到锁被释放。
注意 : 多个线程互斥锁要是同一个
互斥锁的数据类型是 :pthread_mutex_t

初始化

所需头文件
        #include <pthread.h>
函数
        int pthread_mutex_init(pthread_mutex_t *restrict mutex,
                const pthread_mutexattr_t *restrict attr);
参数：
        mutex：互斥锁地址。类型是 pthread_mutex_t 。
        attr：设置互斥量的属性，通常可采用默认属性，即可将 attr 设为 NULL 。
可以使用宏 PTHREAD_MUTEX_INITIALIZER 静态初始化互斥锁 , 比如：
        pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
        这种方法等价于使用 NULL 指定的 attr 参数调用 pthread_mutex_init() 来 完成动态初始化，不同之处在于 PTHREAD_MUTEX_INITIALIZER 宏不进行错误检查。
返回值：
        成功：0 ，成功申请的锁默认是打开的。
        失败：非 0 错误 
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
    //动态获取互斥锁,推荐
    pthread_mutex_t lock;
    pthread_mutex_init(&lock,NULL);
    //静态获取互斥锁,声明与赋值必须同时进程
        pthread_mutex_t lock02 = PTHREAD_MUTEX_INITIALIZER;
    pthread_mutex_destroy(&lock);
    pthread_mutex_destroy(&lock02);
    return 0;
}

销毁

作用 : 销毁互斥锁 , 互斥锁在使用完毕后，必须要对互斥锁进行销毁，以释放资源。
所需头文件
        #include <pthread.h>
函数
        int pthread_mutex_destroy(pthread_mutex_t *mutex);
参数：
        mutex：互斥锁地址。
返回值 :
        成功：0
        失败：非 0 错误码 
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
    //动态获取互斥锁,推荐
    pthread_mutex_t lock;
    pthread_mutex_init(&lock,NULL);
    //静态获取互斥锁
    pthread_mutex_t lock02 = PTHREAD_MUTEX_INITIALIZER;
    pthread_mutex_destroy(&lock);
    pthread_mutex_destroy(&lock02);
    return 0;
}

上锁

作用 : 对互斥锁上锁，若互斥锁已经上锁，则调用者阻塞，直到互斥锁解锁后再上锁。
所需头文件
        #include <pthread.h>
函数
        int pthread_mutex_lock(pthread_mutex_t *mutex);
参数：
        mutex：互斥锁地址。
返回值：
        成功：0
        失败：非 0 错误码

解锁

作用 : 对指定的互斥锁解锁。
所需头文件
        #include <pthread.h>
函数
i        nt pthread_mutex_unlock(pthread_mutex_t *mutex);
参数：
        mutex：互斥锁地址。
返回值：
        成功：0
        失败：非 0 错误码

死锁

概念 : 多个线程互相持有对方所需的锁资源
结果 : 程序无法向下运行 , 所以不会结束 , 但又不能执行代码
总结 : 避免死锁 
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
pthread_mutex_t lockA,lockB;
void *testA(void *argv)
{
    pthread_mutex_lock(&lockA);
    printf("线程%ld进入锁A中\n",pthread_self());
    sleep(1);
    pthread_mutex_lock(&lockB);
    printf("线程%ld进入锁B中\n",pthread_self());
    sleep(1);
    pthread_mutex_unlock(&lockA);
    pthread_mutex_unlock(&lockB);
    return NULL;
}
void *testB(void *argv)
{
    pthread_mutex_lock(&lockB);
    printf("线程%ld进入锁B中\n",pthread_self());
    sleep(1);
    pthread_mutex_lock(&lockA);
    printf("线程%ld进入锁A中\n",pthread_self());
    sleep(1);
    pthread_mutex_unlock(&lockA);
    pthread_mutex_unlock(&lockB);
    return NULL;
}
int main(int argc, char const *argv[])
{
    pthread_mutex_init(&lockA,NULL);
    pthread_mutex_init(&lockB,NULL);
    pthread_t t1,t2;
    pthread_create(&t1,NULL,testA,NULL);
    pthread_create(&t2,NULL,testB,NULL);
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    pthread_mutex_destroy(&lockB);
    pthread_mutex_destroy(&lockA);
    printf("主线程OVER\n");
    return 0;
}

读写锁

        一个特殊的锁
        含有读写两种互斥锁
        其中读读不互斥, 读写互斥 , 写写互斥
        在使用多个线程对同一个数据进行读写时建议使用
        读写锁的数据类型是： pthread_rwlock_t
经验 :
        如果只有两个线程, 一个读 , 一个写 , 此时没必要使用读写锁 , 普通的互斥锁也是可以 的

初始化

作用：用来初始化 rwlock 所指向的读写锁。

所需头文件
        #include <pthread.h>
函数
        int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
                const pthread_rwlockattr_t *restrict attr);
参数：
        rwlock：指向要初始化的读写锁指针。
        attr：读写锁的属性指针。如果 attr 为 NULL 则会使用默认的属性初始化读写 锁，否则使用指定的 attr 初始化读写锁。
        可以使用宏PTHREAD_RWLOCK_INITIALIZER 静态初始化互斥锁 , 比如：
        pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
返回值：
        成功：0 ，读写锁的状态将成为已初始化和已解锁。
        失败：非 0 错误码 
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    //动态初始化,推荐
    pthread_rwlock_t rwlock01;
    pthread_rwlock_init(&rwlock01,NULL);
    //静态初始化,不建议使用,声明与复制必须同时进行
    pthread_rwlock_t rwlock02 = PTHREAD_RWLOCK_INITIALIZER;
    return 0;
}
//注意:vscode编写时不会提示,需要手动编写

销毁

作用：用于销毁一个读写锁，并释放所有相关联的资源（所谓的所有指的是pthread_rwlock_init() 自动申请的资源）

所需头文件
        #include <pthread.h>
函数
        int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
参数：
        rwlock：读写锁指针。
返回值：
        成功：0
        失败：非 0 错误码 
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    //动态初始化,推荐
    pthread_rwlock_t rwlock01;
    pthread_rwlock_init(&rwlock01,NULL);
    //静态初始化,不建议使用,声明与复制必须同时进行
    pthread_rwlock_t rwlock02 = PTHREAD_RWLOCK_INITIALIZER;
    pthread_rwlock_destroy(&rwlock01);
    pthread_rwlock_destroy(&rwlock02);
    return 0;
}

申请读锁

        以阻塞方式在读写锁上获取读锁（读锁定）。
        如果没有写者持有该锁，并且没有写者阻塞在该锁上，则调用线程会获取读锁。
        如果调用线程未获取读锁，则它将阻塞直到它获取了该锁。一个线程可以在一个读写锁上多次执行读锁定。
        线程可以成功调用 pthread_rwlock_rdlock() 函数 n 次，但是之后该线程必须调用
pthread_rwlock_unlock() 函数 n 次才能解除锁定。

所需头文件
        #include <pthread.h>
函数
        int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
参数：
        rwlock：读写锁指针。
返回值：
        成功：0
        失败：非 0 错误码
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
参数：
        rwlock：读写锁指针。
        用于尝试以非阻塞的方式来在读写锁上获取读锁。
        如果有任何的写者持有该锁或有写者阻塞在该读写锁上，则立即失败返回。

申请写锁

        在读写锁上获取写锁（写锁定）。
        如果没有写者持有该锁，并且没有写者读者持有该锁，则调用线程会获取写锁。
        如果调用线程未获取写锁，则它将阻塞直到它获取了该锁。
所需头文件
        #include <pthread.h>
函数
        int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
参数：
        rwlock：读写锁指针。
返回值：
        成功：0
        失败：非 0 错误码
        int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
        用于尝试以非阻塞的方式来在读写锁上获取写锁。
        如果有任何的读者或写者持有该锁，则立即失败返回。

释放读写锁

作用：无论是读锁或写锁，都可以通过此函数解锁

所需头文件
        #include <pthread.h>
函数
        int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
参数：
        rwlock：读写锁指针。
返回值：
        成功：0
        失败：非 0 错误码 
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
pthread_rwlock_t rwlock;
//多线程公共读写数据
int num = 0;
void *writeNum(void *x)
{
    pthread_rwlock_wrlock(&rwlock);
    sleep(2);
    num = rand()%100;
    printf("线程%ld写入后num=%d\n",pthread_self(),num);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}
void *readNum(void *argv)
{
    pthread_rwlock_rdlock(&rwlock);
    sleep(2);
    printf("线程%ld读取到的num=%d\n",pthread_self(),num);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}
void closeThread(pthread_t ps[],int len)
{
    int i;
    for (i = 0; i < len; i++)
    {
        pthread_t t = ps[i];
        pthread_join(t,NULL);
    }
}
int main(int argc, char const *argv[])
{
    //初始化读写锁
    pthread_rwlock_init(&rwlock,NULL);
    //设置随机数种子
    srand(time(NULL));
    //声明3个线程写
    pthread_t tw[3];
    for(int i = 10; i < 13; i++)
    {
        pthread_create(&tw[i-10],NULL,writeNum,NULL);
    }
    //声明10个线程读
    pthread_t tr[10];
    for(int i = 0; i < 10; i++)
    {
        pthread_create(&tr[i],NULL,readNum,NULL);
    }
    int wlen = sizeof(tw)/sizeof(pthread_t);
    closeThread(tw,wlen);
    int rlen = sizeof(tw)/sizeof(pthread_t);
    closeThread(tr,rlen);
    pthread_rwlock_destroy(&rwlock);
    return 0;
}

条件变量

        与互斥锁不同，条件变量是用来等待而不是用来上锁的，条件变量本身不是锁！
        条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。
条件变量的两个动作：
        条件不满足, 阻塞线程
        当条件满足, 通知阻塞的线程开始工作
条件变量的类型 : pthread_cond_t 。

初始化

所需头文件
        #include <pthread.h>
函数
        int pthread_cond_init(pthread_cond_t *restrict cond,
                const pthread_condattr_t *restrict attr);
参数：
        cond：指向要初始化的条件变量指针。
        attr：条件变量属性，通常为默认值，传 NULL 即可
        也可以使用静态初始化的方法，初始化条件变量：
                pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
返回值：
        成功：0
        失败：非 0 错误号

释放

所需头文件
        #include <pthread.h>
函数
        int pthread_cond_destroy(pthread_cond_t *cond);
参数：
        cond：指向要初始化的条件变量指针
返回值：
        成功：0
        失败：非 0 错误

等待条件满足

阻塞等待一个条件变量
        a) 阻塞等待条件变量 cond （参 1 ）满足
        b) 释放已掌握的互斥锁（解锁互斥量）相当于 pthread_mutex_unlock(&mutex);
                a) b) 两步为一个原子操作。( 原子操作即中间不能插入其他操作 )
        c) 当被唤醒， pthread_cond_wait 函数返回时， 解除阻塞并重新申请获取互斥锁pthread_mutex_lock(&mutex);
所需头文件
        #include <pthread.h>
函数
        int pthread_cond_wait(pthread_cond_t *restrict
                cond,pthread_mutex_t *restrict mutex);
参数：
        cond：指向要初始化的条件变量指针
        mutex：互斥锁
返回值：
        成功：0
        失败：非 0 错误号
所需头文件
        #include <pthread.h>
函数
        int pthread_cond_timedwait(pthread_cond_t *restrict cond,
                pthread_mutex_t *restrict mutex,
                        const struct timespec *restrict abstime);
功能：
        限时等待一个条件变量
参数：
        cond：指向要初始化的条件变量指针
        mutex：互斥锁
        abstime：绝对时间
返回值：
        成功：0
        失败：非 0 错误号

唤醒等待

所需头文件
        #include <pthread.h>
函数
        int pthread_cond_signal(pthread_cond_t *cond);
功能：
        唤醒至少一个阻塞在条件变量上的线程
参数
        cond:指向要初始化的条件变量指
返回值
        成功：0
        失败：非 0 错误号
所需头文件
        #include <pthread.h>
函数
        int pthread_cond_broadcast(pthread_cond_t *cond);
功能：
        唤醒全部阻塞在条件变量上的线程
参数：
        cond:指向要初始化的条件变量指针
返回值：
        成功：0
        失败：非 0 错误号

案例1:条件变量基本演示

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
//声明互斥锁
pthread_mutex_t lock;
//声明条件变量
pthread_cond_t cond;
void *test01()
{
    pthread_mutex_lock(&lock);
    printf("线程%ld陷入休眠\n",pthread_self());
    pthread_cond_wait(&cond,&lock);
    printf("线程%ld被唤醒\n",pthread_self());
    pthread_mutex_unlock(&lock);
}
int main(int argc, char const *argv[])
{
    //声明线程
    pthread_t t01,t02;
    //初始化互斥锁
    pthread_mutex_init(&lock,NULL);
    //初始化条件变量
    pthread_cond_init(&cond,NULL);
    //创建线程
    pthread_create(&t01,NULL,test01,NULL);
    pthread_create(&t02,NULL,test01,NULL);
    sleep(5);
    //随机唤醒一个
    //pthread_cond_signal(&cond);
    //唤醒所有
    pthread_cond_broadcast(&cond);
    //销毁显示
    pthread_join(t01,NULL);
    pthread_join(t02,NULL);
    //释放互斥锁
    pthread_mutex_destroy(&lock);
    //释放条件变量
    pthread_cond_destroy(&cond);
    return 0;
}

案例2:生产者与消费者模式

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
//声明互斥锁
pthread_mutex_t lock;
//声明条件变量
pthread_cond_t cond;
//声明记录库存数量的变量
int num = 0;
//声明生产的方法
void *produce(void *argv);
//声明销售的方法
void *sale(void *argv);
//声明释放线程的方法
void closeThread(pthread_t ts[],int len)
{
    for(int i = 0; i < len; i++)
    {
        pthread_join(ts[i],NULL);
    }
}
int main(int argc, char const *argv[])
{
    srand(time(NULL));
    //初始化互斥锁
    pthread_mutex_init(&lock,NULL);
    //初始化条件变量
    pthread_cond_init(&cond,NULL);
    //声明生产者线程组
    pthread_t ps[3];
    //声明销售者线程组
    pthread_t ss[5];
    //创建线程并执行
    int i;
    for(i = 0; i < 3; i++)
    {
        pthread_create(&ps[i],NULL,produce,NULL);
    }
    for(int i = 0; i < 5; i++)
    {
        pthread_create(&ps[i],NULL,sale,NULL);
    }
    //释放生产者线程
    int plen = sizeof(ps)/sizeof(pthread_t);
    closeThread(ps,plen);
    //释放消费者线程
    int slen = sizeof(ss)/sizeof(pthread_t);
    closeThread(ss,slen);
    //释放互斥锁
    pthread_mutex_destroy(&lock);
    //释放条件变量
    pthread_cond_destroy(&cond);
    return 0;
}
void *produce(void *argv)
{
    while(1){
        pthread_mutex_lock(&lock);
        while(num >= 10)
        {
            printf("库存已满,线程%ld停止生产\n",pthread_self());
            pthread_cond_wait(&cond,&lock);
        }
        num++;
        printf("线程%ld生产了一个商品,当前库存数量为:%d\n",pthread_self(),num);
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&lock);
        sleep(1);
    }
    return NULL;
}
void *sale(void *argv)
{
    while(1)
    {
        pthread_mutex_lock(&lock);
        while(num <= 0)
        {
            printf("库存为0,线程%ld停止销售\n",pthread_self());
            pthread_cond_wait(&cond,&lock);
        }
        num--;
        printf("线程%ld销售了一个商品,当前库存数量为:%d\n",pthread_self(),num);
        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&lock);
        int t = rand()%5;
        sleep(t);
    }
}

信号量

        信号量广泛用于进程或线程间的同步和互斥, 信号量本质上是一个非负的整数计数器 , 它 被用来控制对公共资源的访问
        当信号量值大于0 时，则可以访问 , 否则将阻塞 .
        PV 原语是对信号量的操作 , 一次 P 操作使信号量减１，一次 V 操作使信号量加 1.
信号量数据类型为： sem_t

初始化信号量

所需头文件
        #include <semaphore.h>
函数
        int sem_init(sem_t *sem, int pshared, unsigned int value)
功能：
        创建一个信号量并初始化它的值。一个无名信号量在被使用前必须先初始化。
参数：
        sem：信号量的地址
        pshared：等于 0 ，信号量在线程间共享（常用）；不等于 0 ，信号量在进程间共 享。
        value：信号量的初始值
返回值：
        成功：0
        失败： - 1

p操作-信号量-1

所需头文件
        #include <semaphore.h>
函数
        int sem_wait(sem_t *sem);
功能 :
        将信号量减一, 如果信号量的值为 0 则阻塞 , 大于 0 可以减一
参数 :
        信号量的地址
返回值 :
        成功返回 0
        失败返回 -1
所需头文件
        #include <semaphore.h>
函数
        int sem_trywait(sem_t *sem);
功能 :
        尝试将信号量减一, 如果信号量的值为 0 不阻塞 , 立即返回 , 大于 0 可以减一
参数 :
        信号量的地址
返回值 :
        成功返回 0
        失败返回 -1

v操作-信号量+1

所需头文件
        #include <semaphore.h>
函数
        int sem_post(sem_t *sem);
功能 :
        将信号量加一
参数 :
        信号量的地址
返回值 :
        成功返回 0
        失败返回-1

销毁信号量

所需头文件
        #include <semaphore.h>
函数
        int sem_destroy(sem_t *sem);
功能 :
        销毁信号量
参数 :
        信号量的地址
返回值 :
        成功返回 0
        失败返回 -1

线程间

信号量完成互斥

        不管有多少个任务，只要是互斥，只要一个信号量，并且初始化1.
        当任务x 开始时 , 让信号量进行 p 操作 , 此时信号量为 0, 其他任务此时就会被阻塞 , 当任务 x 结束时让任务, 让信号量 v 操作 , 这样别的任务就可以执行了 
#include <stdio.h>
#include <semaphore.h>
#include <pthread.h>
#include <unistd.h>
sem_t sem;
void *printstr(void *argv)
{
    sem_wait(&sem);
    char * str = (char *)argv;
    int i = 0;
    while(str[i] != '\0')
    {
        printf("%c\n",str[i]);
        i++;
        sleep(1);
    }
    sem_post(&sem);
    return NULL;
}
int main(int argc, char const *argv[])
{
    //初始化信号量,0表示线程 1初始值
    sem_init(&sem,0,1);
    pthread_t t01,t02,t03;
    pthread_create(&t01,NULL,printstr,"HELLO");
    pthread_create(&t02,NULL,printstr,"c++");
    pthread_create(&t03,NULL,printstr,"Java");
    pthread_join(t01,NULL);
    pthread_join(t02,NULL);
    pthread_join(t03,NULL);
    //释放信号量
    sem_destroy(&sem);
    return 0;
}

信号量完成同步

        有几个任务就需要有几个信号量，先执行为任务的信号初始化为1 ，其他信号量初始化为0 ，
        所有任务P(-1) 自己的信号， V(+1) 下一个任务的信号量。 
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
sem_t s01,s02,s03;
void *print01(void *argv)
{
    sem_wait(&s01);
    printf("线程1输入\n");
    sem_post(&s02);
    return NULL;
}
void *print02(void *argv)
{
    sem_wait(&s02);
    printf("线程2输入\n");
    sem_post(&s03);
    return NULL;
}
void *print03(void *argv)
{
    sem_wait(&s03);
    printf("线程3输入\n");
    sem_post(&s01);
    return NULL;
}
int main(int argc, char const *argv[])
{
    sem_init(&s01,0,1);
    sem_init(&s02,0,0);
    sem_init(&s03,0,0);
    pthread_t t01,t02,t03;
    pthread_create(&t01,NULL,print01,NULL);
    pthread_create(&t02,NULL,print02,NULL);
    pthread_create(&t03,NULL,print03,NULL);
    pthread_join(t01,NULL);
    pthread_join(t02,NULL);
    pthread_join(t03,NULL);
    sem_destroy(&s01);
    sem_destroy(&s02);
    sem_destroy(&s03);
    return 0;
}

进程间

无名信号量

无名信号量用于 有血缘关系进程间的同步互斥。
mmap 创建无名信号量 ( 也可以通过别的方式 ) ：
        #include <sys/mman.h>
        #include <semaphore.h>
                //MAP_ANONYMOUS匿名映射( 映射没有任何文件支持；其内容被初始化为零。 ) -1 不需要文件描述符
                sem_t *sem = mmap(NULL,sizeof(sem_t), PROT_READ|PROT_WRITE,
        MAP_SHARED|MAP_ANONYMOUS, -1, 0);
有血缘进程的互斥 : 案例 1 
#include <stdio.h>
#include <unistd.h>
#include <semaphore.h> //信号量
#include <sys/mman.h> //mmap
#include <sys/wait.h> //wait
void print_string(void *str)
{
    char *p = (char *)str;
    int i = 0;
    while (p[i] != '\0')
    {
        printf("%c", p[i++]);
        fflush(stdout);
        sleep(1);
    }
}
int main(int argc, char const *argv[])
{
    //创建无名信号量
    // MAP_ANONYMOUS匿名映射 -1不需要文件描述符
    sem_t *sem = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE,
    MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    //初始化信号量 1表示作用于进程 1初始值
    sem_init(sem, 1, 1);
    pid_t pid = fork();
    if (pid == 0) //子进程
    {
        // p 操作
        sem_wait(sem);
        print_string("ni hao");
        // V 操作
        sem_post(sem);
        _exit(-1);
    }
    else if (pid > 0) //父进程
    {
        // p 操作
        sem_wait(sem);
        print_string("hello world");
        // V 操作
        sem_post(sem);
        wait(NULL);
    }
    //销毁信号量
    sem_destroy(sem);
    return 0;
}
有血缘进程间互斥 : 案例 2 
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/mman.h>
void printStr(char *str)
{
    int i = 0;
    while(str[i] != '\0')
    {
        printf("%c\n",str[i]);
        fflush(stdout);
        i++;
        sleep(1);
    }
    printf("\n");
}
int main(int argc, char const *argv[])
{
    //通过mmap(磁盘映射)创建有缘信号量
    sem_t *sem = (sem_t *)mmap(NULL,//映射区域地址,给NULL内核会自己选择合适的区域
    sizeof(sem_t),//映射区域大学
    PROT_READ | PROT_WRITE,//权限:可读,可写
    MAP_SHARED | MAP_ANONYMOUS,//标志位:共享的 | 映射没有任何文件支持；其内容被初始化为零
    -1,//文件标识符,当标志位有MAP_ANONYMOUS,文件标识符必须为-1
    0);//偏移量
        //初始化信号量
    //1参:要初始化的信号量指针
    //2参:0线程间共享,非0进程间共享
    //3参:信号量初始值
    sem_init(sem,1,1);
    int i = 0;
    for (i = 0; i < 2; i++)
    {
        pid_t pid = fork();
        if (pid == 0)
        {
            printf("进程%d被创建了\n",getpid());
            break;
        }
    }
    if (i == 0)
    {
        //子进程1
        //p操作,信号量-1
        sem_wait(sem);
        printStr("hello");
        sem_post(sem);
        _exit(-1);
    }
    else if(i == 1)
    {
        //子进程2
        sem_wait(sem);
        printStr("c++");
        sem_post(sem);
        _exit(-1);
    }
    else if(i == 2)
    {
        //父进程
        while (1)
        {
            //-1,等待任意子进程结束回收,
            //WNOHANG:不阻塞
            //返回值:被回收的子进程id
            pid_t pid = waitpid(-1,NULL,WNOHANG);
            if (pid > 1)
            {
                printf("进程%d,被回收了\n",pid);
            }
            else if (pid == 0)
            {
                //当pid为0说明当前并没有回收到子进程,还有子进程在运行
                    continue;
            }
            else if(pid < 0)
            {
                //当pid小于0说明当前父进程中已经没有子进程了
                break;
            }
        }
        //销毁信号量
        sem_destroy(sem);
    }
    getchar();
    return 0;
}
有血缘进程间同步 
#include <stdio.h>
#include <unistd.h>
#include <semaphore.h> //信号量
#include <sys/mman.h> //mmap
#include <sys/wait.h> //wait
void print_string(void *str)
{
    char *p = (char *)str;
    int i = 0;
    while (p[i] != '\0')
    {
        printf("%c", p[i++]);
        fflush(stdout);
        sleep(1);
    }
}
int main(int argc, char const *argv[])
{
    //创建无名信号量
    // MAP_ANONYMOUS匿名映射 -1不需要文件描述符
    sem_t *sem1 = (sem_t *)mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE,
    MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    sem_t *sem2 = (sem_t *)mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE,
    MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    //初始化信号量 1表示作用于进程 1初始值
    sem_init(sem1, 1, 1);
    sem_init(sem2, 1, 0);
    pid_t pid = fork();
    if (pid == 0) //子进程
    {
        // p 操作
        sem_wait(sem1);
        print_string("ni hao");
        // V 操作
        sem_post(sem2);
        _exit(-1);
    }
    else if (pid > 0) //父进程
    {
        // p 操作
        sem_wait(sem2);
        print_string("hello world");
        // V 操作
        sem_post(sem1);
        wait(NULL);
    }
        //销毁信号量
    sem_destroy(sem1);
    sem_destroy(sem2);
    return 0;
}

有名信号量

有名信号量用于无血缘关系进程间的同步互斥。
所需头文件
        #include <fcntl.h> /* For O_* constants */
        #include <sys/stat.h> /* For mode constants */
        #include <semaphore.h>
函数
        //信号量存在
        sem_t *sem_open(const char *name, int oflag);
        //信号量不存在
        sem_t *sem_open(const char *name, int oflag,mode_t mode, unsigned int value);
        Link with -pthread.
        功能：创建一个有名信号量。
参数：
        name:信号量的标识符 , 建议以 / 开始 ( 存储在 /dev/shm 目录下 )
        oflag:和 open 函数的 flag 一致
        mode:磁盘权限 0666
        value:信号量的初始值
返回值：
        成功就是信号量的地址
        失败为NULL
        #include <semaphore.h>
        int sem_close(sem_t *sem);
        Link with -pthread
        功能: 关闭信号量
参数 :
        信号量地址
        #include <unistd.h>
        int unlink(const char *pathname);
        功能: 删除文件
参数 :
        文件地址
返回值 :
        成功返回 0
        失败返回-1

无血缘进程互斥

//18_codeA.c
#include <stdio.h>
#include <unistd.h>
#include <semaphore.h>
#include <fcntl.h>
#include <sys/stat.h>
void printStr(char *str)
{
    int i = 0;
    while(str[i] != '\0')
    {
        printf("%c\n",str[i]);
        i++;
        sleep(1);
    }
}
int main(int argc, char const *argv[])
{
    sem_t *sem = sem_open("sem",O_RDWR | O_CREAT,0666,1);
    sem_wait(sem);
    printStr("hello 123");
    sem_post(sem);
    sem_close(sem);
    sem_destroy(sem);
    return 0;
}
//18_codeB.c
#include <stdio.h>
#include <unistd.h>
#include <semaphore.h>
#include <fcntl.h>
#include <sys/stat.h>
void printStr(char *str)
{
    int i = 0;
    while(str[i] != '\0')
    {
        printf("%c\n",str[i]);
        i++;
        sleep(1);
    }
}
int main(int argc, char const *argv[])
{
    sem_t *sem = sem_open("sem",O_RDWR | O_CREAT,0666,1);
    sem_wait(sem);
    printStr("Hi C++");
    sem_post(sem);
    sem_close(sem);
    sem_destroy(sem);
    return 0;
}

有血缘进程同步

//19_codeA.c
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>
void print_string(void *str)
{
    char *p = (char *)str;
    int i = 0;
    while (p[i] != '\0')
    {
        printf("%c", p[i++]);
        fflush(stdout);
        sleep(1);
    }
}
int main(int argc, char const *argv[])
{
    //创建一个有名信号量
    sem_t *sem1 = sem_open("sem1", O_RDWR | O_CREAT, 0666, 1);
    sem_t *sem2 = sem_open("sem2", O_RDWR | O_CREAT, 0666, 0);
    // P 操作
    sem_wait(sem1);
    print_string("nihao xian");
    // V 操作
    sem_post(sem2);
    //关闭信号量
    sem_close(sem1);
    sem_close(sem2);
    //销毁信号
    sem_destroy(sem1);
    sem_destroy(sem2);
    return 0;
}
//19_codeB.c
#include <fcntl.h> /* For O_* constants */
#include <sys/stat.h> /* For mode constants */
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>
void print_string(void *str)
{
    char *p = (char *)str;
    int i = 0;
    while (p[i] != '\0')
    {
        printf("%c", p[i++]);
        fflush(stdout);
        sleep(1);
    }
}
int main(int argc, char const *argv[])
{
    //创建一个有名信号量
    sem_t *sem1 = sem_open("sem1", O_RDWR | O_CREAT, 0666, 1);
    sem_t *sem2 = sem_open("sem2", O_RDWR | O_CREAT, 0666, 0);
    // P 操作
    sem_wait(sem2);
    print_string("hello world");
    // V 操作
    sem_post(sem1);
        //关闭信号量
    sem_close(sem1);
    sem_close(sem2);
    //销毁信号
    sem_destroy(sem1);
    sem_destroy(sem2);
    return 0;
}

纳尔哒哒
关注
  • 28
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【操作系统】多线程同步与互斥
兔子王
11-04 2423
【实验内容】（1）编写程序，使用Linux操作系统中的信号量机制模拟实现生产者-消费者问题。设有一个生产者和一个消费者，缓冲区可以存放产品，生产者不断生成产品放入缓冲区，消费者不断从缓冲区中取出产品，消费产品。（2）以上实验只模拟了一个产品的放入与取出，请修改代码，以模拟实现多个产品的放入与取出。
Linux ： 线程的同步与互斥（模拟买票系统）
TheWindRisesll的博客
01-21 652
线程的同步与互斥 进程线程间的互斥相关背景概念 【临界资源】：多线程执行流共享的资源就叫做临界资源 【临界区】：每个线程内部，访问临界自娱的代码，就叫做临界区 【互斥】：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用 【原子性】：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成 互斥量mutex 大部分情况，线程使用的数据都是局部变量，变...
vscode 中 pthread_rwlock_t 未定义的问题
Joe277933的博客
08-23 763
2.若添加头文件之后依旧报错，直接在代码最顶端添加宏定义（这是个简单粗暴方法）编写读写锁时，定义读写锁变量时vscode 警告未定义pthread_rwlock_t 参数时。解决方式：1. 头文件是否添加 #include
【Linux】vscode 对 pthread_rwlock_t 等报错 解决方法
weixin_46512400的博客
07-20 481
在Linux环境下使用 VScode 编写C代码，在进行关于进程、现程开发的时候，一些系统调用或者定义（比如像等) 编辑器都无法解析出来，经常会出现无法跳转函数定义、飘红等，除了没有 include 相关的头文件之外，很可能是没有进行宏定义导致的 VScode 解析器无法识别。
[并发并行]_[中级]_[实现Pthread线程并发读写锁rwlock]
Tobey(我是机器人)
03-31 1590
场景1.所有STL的类实例都是并发读线程安全的,除了shared_ptr,iostream 可允许并发写.在设计对象结构时,往往会用到std::vector,std::map 作为容器存储. 并在多线程程序里并发读写. 当然如果牺牲性能只在一个特定线程里读/写当然也可以,只是性能会降低,而且会带来异步执行的烦恼.2.当然如果多线程可以读写,那么对这个共享对象是需要加锁的, 而多线程的坏处是你并不知道
vscode 远程 Ubuntu 静态连接 pthread，执行报错：segmentation fault
kencao01的博客
10-07 349
参考链接： https://stackoverflow.com/questions/58848694/gcc-whole-archive-recipe-for-static-linking-to-pthread-stopped-working-in-rec vscode task.json 设置： "args": [ "-g", "${file}", "-std=c++17", "-Wall", "-static", "-Wl,--whole-archive", "-lrt",
Day08 Liunx高级系统设计9-线程间同步与互斥
aisheisadas的博客
12-13 1289
一个特殊的锁含有读写两种互斥锁其中读读不互斥读写互斥写写互斥在使用多个线程对同一个数据进行读写时建议使用读写锁的数据类型是：经验如果只有两个线程一个读一个写此时没必要使用读写锁普通的互斥锁也是可以的。
【Linux】——线程同步与互斥
qq_43412060的博客
06-28 445
1、同步和互斥的概念 2、互斥锁（同步） 3、条件变量（同步） 4、读写锁（同步） 5、信号量（同步与互斥）
Linux操作系统编程(linux多线程的互斥与同步控制及实践)
02-11
在深入讨论Linux操作系统编程，特别是多线程的互斥与同步控制及实践之前，首先需要了解Linux操作系统的基本概念以及多线程编程的基础知识。Linux是一种类Unix的操作系统，它支持多用户、多任务、多线程和多种硬件...
操作系统课程设计-线程和进程的同步与互斥
风格色的博客
12-29 5601
操作系统的课程设计 多线程和多进程同步方法解决水果分配问题： 水果分配的问题： 桌上有一只盘子，每次只能放入5只水果。爸爸专放苹果， 妈妈专放橘子，一个儿子专等吃盘子中的橘子，一个女儿专等吃盘子中的苹果.用P，V操作实现爸爸、妈妈、儿子、女儿进程的同步控制。 补充：设有两个篮子，分别有若干个苹果或橘子，爸爸和妈妈将每次从水果篮子中拿出一个水果放入水果盘中，儿子女儿则挑选各自喜欢的水果。
【Linux】多线程同步与互斥
gangaue的博客
01-25 935
这篇文章给大家带来线程同步与互斥的学习！！！
VSCode开发配置、代码比对、pthread、QT
yiyayiya557的博客
07-09 1403
参考文章： VSCode开发配置 VSCode 配置CUDA编程环境（较完整） https://blog.csdn.net/u012435142/article/details/102651892 Visual Studio Code (vscode) 配置 C / C++ 环境（较简单，入门级） https://www.cnblogs.com/bpf-1024/p/11597000.html Ubuntu16.04下配置VScode的C/C++开发环境（比较原始，意义不大） https://
读写锁pthread_rwlock_t的使用
weixin_45606237的博客
04-06 1096
读写锁pthread_rwlock_t的使用1目的2阻塞读锁定和写锁定的使用3非阻塞读锁定和写锁定4非阻塞读锁定和写锁定的例子 1目的 读写锁是用来解决读者写者问题的，读操作可以共享，写操作是排他的，读可以有多个在读，写只有唯一个在写，同时写的时候不允许读。对于读数据比修改数据频繁的应用，用读写锁代替互斥锁可以提高效率，强烈推荐读写锁 2阻塞读锁定和写锁定的使用 #include <pthread.h>//需要包含该头文件 pthread_rwlock_t rwlock_; pthread_rw
解决ubuntu下vscode的undefined pthread问题
sunmengke1101的博客
09-06 1255
解决ubuntu下vscode编译运行多线程c文件报错问题
【Linux】：信号与信号产生
最新发布
Yikefore的博客
09-12 619
信号的基本概念、对信号的理解、信号的多种产生方式以及核心转储的详细介绍！
Linux 进程控制
2302_77289177的博客
09-08 1213
Linux 进程控制
高效诊断Linux性能问题
Tiger93的博客
09-08 515
诊断Linux性能问题
＜Linux＞ 基础IO
prodigy623的博客
09-06 1056
详解Linux基础IO：文件系统调用接口与C库文件函数的关系、重定向、数据缓冲区、文件系统、动静态库
Linux多线程互斥与同步实践：N2(9S系统中的线程机制
文中探讨了线程的概念，如何在Linux（N2(9S系统）中实现线程机制，并介绍了线程间的互斥与同步策略，以确保多线程程序的正确运行。" 在Linux操作系统编程中，多线程是一种提升程序并发性和效率的重要技术。线程是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值