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

同步与互斥的概念

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

同步：同一时间，只能有一个任务（进程或线程）执行，有顺序的执行。

同步是特殊的互斥。

锁（互斥锁）

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

用于线程的互斥。

互斥锁是一种简单的加锁的方法来控制对共享资源的访问。

互斥锁只有两种状态 , 即加锁 ( 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;
}