兴义网站seo,开一个网站需要什么,网络运维工程师需要具备什么证书,wordpress手机认证登录目录
同步互斥的概念
互斥锁
初始化互斥锁
销毁互斥锁
申请上锁
解锁
案例1#xff1a;没有互斥锁 多任务的运行情况 案例2#xff1a;有互斥锁 多任务的运行情况
死锁
读写锁
初始化读写锁
销毁读写锁
申请读锁
申请写锁
释放读写锁
案例#xff1a;两个任务…目录
同步互斥的概念
互斥锁
初始化互斥锁
销毁互斥锁
申请上锁
解锁
案例1没有互斥锁 多任务的运行情况 案例2有互斥锁 多任务的运行情况
死锁
读写锁
初始化读写锁
销毁读写锁
申请读锁
申请写锁
释放读写锁
案例两个任务读 一个任务写
条件变量重要
概念引入
概念原理 条件变量初始化
释放条件变量
等待条件
唤醒等待在条件变量上的线程
案例生产者和消费者
信号量
信号量的API
初始化信号量
信号量减一 P操作
信号量加一 V操作
销毁信号量
使用场景
信号量用于线程的互斥 信号量用于线程的同步
无名信号量 用于 血缘关系的进程间互斥
无名信号量 用于 血缘关系的进程间同步
有名信号量 用于 无血缘的进程间互斥
创建一个有名信号量
信号量的关闭
信号量文件的删除
案例完成互斥
有名信号量 用于 无血缘的进程间同步 同步互斥的概念
互斥同一时间只能一个任务进程或线程执行谁先运行不确定。
同步同一时间只能一个任务进程或线程执行有顺序的运行。
同步 是特殊的 互斥。
互斥锁
用于线程的互斥。
互斥锁是一种简单的加锁的方法来控制对共享资源的访问互斥锁只有两种状态,即加锁( lock )和解锁( unlock )
互斥锁的操作流程如下
1在访问共享资源临界区域前对互斥锁进行加锁。
2在访问完成后释放互斥锁上的锁。 解锁
3对互斥锁进行加锁后任何其他试图再次对互斥锁加锁的线程将会被阻塞直到锁 被释放。
互斥锁的数据类型是 pthread_mutex_t
初始化互斥锁
#include pthread.h
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *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 pthread.h
int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能 销毁指定的一个互斥锁。互斥锁在使用完毕后必须要对互斥锁进行销毁以释放资 源。
参数 mutex互斥锁地址。
返回值: 成功0 失败非 0 错误码
申请上锁
#include pthread.h
int pthread_mutex_lock(pthread_mutex_t *mutex);
功能 对互斥锁上锁若互斥锁已经上锁则调用者阻塞直到互斥锁解锁后再上锁。
参数 mutex互斥锁地址。
返回值 成功0 失败非 0 错误码
int pthread_mutex_trylock(pthread_mutex_t *mutex);
调用该函数时若互斥锁未加锁则上锁返回 0
若互斥锁已加锁则函数直接返回失败即 EBUSY。
解锁
#include pthread.h
int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能 对指定的互斥锁解锁。
参数 mutex互斥锁地址。
返回值 成功0 失败非0错误码
案例1没有互斥锁 多任务的运行情况
#include unistd.h
#include stdio.h
#include pthread.hvoid *deal_fun01(void *arg)
{char *str (char*)arg;while(*str!\0){printf(%c,*str);//没有换行符需要强制刷新fflush(stdout);usleep(500000);}return NULL;
}void *deal_fun02(void *arg)
{char *str (char*)arg;while(*str!\0){printf(%c,*str);//没有换行符需要强制刷新fflush(stdout);usleep(500000);}return NULL;
}int main(int argc, char const *argv[])
{//创建两个线程pthread_t tid1,tid2;pthread_create(tid1,NULL,deal_fun01,hello);pthread_create(tid2,NULL,deal_fun02,world);pthread_detach(tid1);pthread_detach(tid2);return 0;
}由于使用了pthread_detach创建的线程还没来得及执行进程就结束了所以导致输出结果不全 使用pthread_join进行阻塞等待线程结束
#include unistd.h
#include stdio.h
#include pthread.hvoid *deal_fun01(void *arg)
{char *str (char*)arg;while(*str!\0){printf(%c,*str);//没有换行符需要强制刷新fflush(stdout);usleep(500000);}return NULL;
}void *deal_fun02(void *arg)
{char *str (char*)arg;while(*str!\0){printf(%c,*str);//没有换行符需要强制刷新fflush(stdout);usleep(500000);}return NULL;
}int main(int argc, char const *argv[])
{//创建两个线程pthread_t tid1,tid2;pthread_create(tid1,NULL,deal_fun01,hello);pthread_create(tid2,NULL,deal_fun02,world);pthread_join(tid1,NULL);pthread_join(tid2,NULL);return 0;
}案例2有互斥锁 多任务的运行情况
#include unistd.h
#include stdio.h
#include pthread.h//定义一把锁
pthread_mutex_t mutex;
void *deal_fun01(void *arg)
{char *str (char*)arg;//上锁pthread_mutex_lock(mutex);while(*str!\0){printf(%c,*str);//没有换行符需要强制刷新fflush(stdout);usleep(500000);}//解锁pthread_mutex_unlock(mutex);return NULL;
}void *deal_fun02(void *arg)
{char *str (char*)arg;//上锁pthread_mutex_lock(mutex);while(*str!\0){printf(%c,*str);//没有换行符需要强制刷新fflush(stdout);usleep(500000);}//解锁pthread_mutex_unlock(mutex);return NULL;
}int main(int argc, char const *argv[])
{//初始化锁pthread_mutex_init(mutex,NULL);//创建两个线程pthread_t tid1,tid2;pthread_create(tid1,NULL,deal_fun01,hello);pthread_create(tid2,NULL,deal_fun02,world);pthread_join(tid1,NULL);pthread_join(tid2,NULL);//销毁锁pthread_mutex_destroy(mutex);return 0;
}由于线程是相互独立的所以线程处理函数可以合成一个函数
#include unistd.h
#include stdio.h
#include pthread.h//定义一把锁
pthread_mutex_t mutex;
void *deal_fun(void *arg)
{char *str (char*)arg;//上锁pthread_mutex_lock(mutex);while(*str!\0){printf(%c,*str);//没有换行符需要强制刷新fflush(stdout);usleep(500000);}//解锁pthread_mutex_unlock(mutex);return NULL;
}int main(int argc, char const *argv[])
{//初始化锁pthread_mutex_init(mutex,NULL);//创建两个线程pthread_t tid1,tid2;pthread_create(tid1,NULL,deal_fun,hello);pthread_create(tid2,NULL,deal_fun,world);pthread_join(tid1,NULL);pthread_join(tid2,NULL);//销毁锁pthread_mutex_destroy(mutex);return 0;
}总结
如果是互斥 不管有多少个任务只需要一把锁所有的任务上锁 访问资源 解锁。
死锁 读写锁 POSIX 定义的读写锁的数据类型是 pthread_rwlock_t
初始化读写锁
#include pthread.h
int pthread_rwlock_init(pthread_rwlock_t *rwlock,const pthread_rwlockattr_t *attr);
功能 用来初始化 rwlock 所指向的读写锁。
参数 rwlock指向要初始化的读写锁指针。 attr读写锁的属性指针。如果 attr 为 NULL 则会使用默认的属性初始化读写锁否则 使用指定的 attr 初始化读写锁。 可以使用宏 PTHREAD_RWLOCK_INITIALIZER 静态初始化读写锁比如 pthread_rwlock_t my_rwlock PTHREAD_RWLOCK_INITIALIZER; 这种方法等价于使用 NULL 指定的 attr 参数调用 pthread_rwlock_init() 来完成动态初 始化不同之处在于PTHREAD_RWLOCK_INITIALIZER 宏不进行错误检查。
返回值 成功0读写锁的状态将成为已初始化和已解锁。 失败非 0 错误码。
销毁读写锁
#include pthread.h
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
功能 用于销毁一个读写锁并释放所有相关联的资源所谓的所有指的是由 pthread_rwlock_init() 自动申请的资源 。
参数 rwlock读写锁指针。
返回值 成功0 失败非 0 错误码
申请读锁
#include pthread.h
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
功能 以阻塞方式在读写锁上获取读锁读锁定。 如果没有写者持有该锁并且没有写者阻塞在该锁上则调用线程会获取读锁。 如果调用线程未获取读锁则它将阻塞直到它获取了该锁。一个线程可以在一个读写锁 上多次执行读锁定。 线程可以成功调用 pthread_rwlock_rdlock() 函数 n 次但是之后该线程必须调用 pthread_rwlock_unlock() 函数 n 次才能解除锁定。
参数 rwlock读写锁指针。
返回值 成功0 失败非 0 错误码
int pthread_rwlock_tryrdlock(pthread_rwlock_t *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 pthread.h
#include unistd.h//创建一把读写锁
pthread_rwlock_t rwlock;void *read_data01(void *arg)
{int *p(int*)arg;while(1){//申请上读锁pthread_rwlock_rdlock(rwlock);printf(任务Anum%d\n,*p);//解读写锁pthread_rwlock_unlock(rwlock);sleep(1);}return NULL;
}void *read_data02(void *arg)
{int *p(int*)arg;while(1){//申请上读锁pthread_rwlock_rdlock(rwlock);printf(任务Bnum%d\n,*p);//解读写锁pthread_rwlock_unlock(rwlock);sleep(1);}return NULL;
}void *write_data(void *arg)
{int *p(int*)arg;while(1){//申请上写锁pthread_rwlock_wrlock(rwlock);(*p);//解读写锁pthread_rwlock_unlock(rwlock);printf(任务C写入num%d\n,*p);sleep(2);}return NULL;
}int main(int argc, char const *argv[])
{//定义一个公共资源int num0;//初始化读写锁pthread_rwlock_init(rwlock,NULL);pthread_t tid1,tid2,tid3;pthread_create(tid1,NULL,read_data01,num);pthread_create(tid2,NULL,read_data02,num);pthread_create(tid3,NULL,write_data,num);pthread_join(tid1,NULL);pthread_join(tid2,NULL);pthread_join(tid3,NULL);//销毁锁pthread_rwlock_destroy(rwlock);return 0;
}条件变量重要
概念引入
对于刚刚死锁的第三种情况。如果任务A先执行上锁由于管道没有数据所以读不到数据会一直阻塞导致无法解锁任务A无法解锁就会导致任务B无法上锁也就无法向管道写入数据同样会导致任务B阻塞等待上锁。
我们按照进程管道通信的方法可以使用非阻塞读取来解决这个死锁问题。 但我们还可以通过条件变量来进行解决任务A在执行到读数据的时候发现管道里没有数据就会通过条件变量临时解锁从而通知任务B成功上锁进行数据写入。 概念原理
条件变量是用来等待条件满足而不是用来上锁的条件变量本身不是锁。
条件变量和互斥锁同时使用。
条件变量的两个动作 条件不满, 阻塞线程。当条件满足, 通知阻塞的线程开始工作。
条件变量的类型: pthread_cond_t。
原子操作 几个操作连续进行不可分割不能被其它代码操作插入和打断。 条件变量初始化
#include pthread.h
int pthread_cond_init(pthread_cond_t *cond,
const pthread_condattr_t *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错误号
等待条件
#include pthread.h
int pthread_cond_wait(pthread_cond_t *cond,
pthread_mutex_t *mutex);
功能 阻塞等待一个条件变量 如果阻塞就 先解锁、等待条件满足、重新上锁3步为原子操作解阻塞
参数 cond指向要初始化的条件变量指针 mutex互斥锁
返回值 成功0 失败非0错误号
int pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t *mutex,const struct *abstime);
功能 限时等待一个条件变量
参数 cond指向要初始化的条件变量指针 mutex互斥锁 abstime绝对时间
返回值 成功0 失败非0错误号
唤醒等待在条件变量上的线程
#include pthread.h
int pthread_cond_signal(pthread_cond_t *cond);
功能 唤醒至少一个阻塞在条件变量上的线程
参数 cond指向要初始化的条件变量指
返回值 成功0 失败非0错误号
int pthread_cond_broadcast(pthread_cond_t *cond);
功能 唤醒全部阻塞在条件变量上的线程
参数 cond指向要初始化的条件变量指针
返回值 成功0 失败非0错误号
案例生产者和消费者 #include pthread.h
#include stdio.h
#include unistd.h
#include stdlib.h
//定义互斥锁
pthread_mutex_t mutex;
//定义条件变量
pthread_cond_t cond;
//定义一个仓库 默认有三个产品
int num 3;void *comsumption_fun(void *arg) //消费
{while (1){//申请上锁pthread_mutex_lock(mutex);//判断仓库是否为空 等待条件变量满足if (0 num) //仓库为空{printf(%s 发现仓库为空等待生产\n, (char *)arg);pthread_cond_wait(cond, mutex);}else{//进入仓库购买产品num--;printf(%s 购买了一个产品仓库剩余%d个\n, (char *)arg, num);//使用产品printf(%s 正在使用产品\n, (char *)arg);}//解锁pthread_mutex_unlock(mutex);sleep(rand() % 5);}
}void *production_fun(void *arg) //生产
{while (1){//生产一个产品sleep(rand() % 5);//上锁 进入仓库pthread_mutex_lock(mutex);//将产品放入仓库num;printf(%s 放入一个产品仓库剩余%d\n, (char *)arg, num);//通知 条件变量阻塞的线程pthread_cond_broadcast(cond);//解锁pthread_mutex_unlock(mutex);}
}
int main(int argc, char const *argv[])
{//设计随机数种子srand(time(NULL));//初始化锁pthread_mutex_init(mutex, NULL);//初始化条件变量pthread_cond_init(cond, NULL);pthread_t tid1, tid2, tid3;pthread_create(tid1, NULL, comsumption_fun, 消费者A);pthread_create(tid2, NULL, comsumption_fun, 消费者B);pthread_create(tid3, NULL, production_fun, 生产者);//等待线程结束pthread_join(tid1, NULL);pthread_join(tid2, NULL);pthread_join(tid3, NULL);//销毁锁pthread_mutex_destroy(mutex);//销毁条件变量pthread_cond_destroy(cond);return 0;
}信号量
信号量也叫信号灯其本质就是一个计数器描述临界资源的数目大小。最多能有多少资源分配给线程。 信号量可参考信号量的概念 及其 操作函数有名、无名信号量_仲夏夜之梦~的博客-CSDN博客 前面的锁和条件变量只用于线程间同步互斥。而信号量广泛用于进程或线程间的同步和互斥信号量本质上是一个非负的整数计数器它被 用来控制对公共资源的访问。
适用于六种情况线程间的同步与互斥、有血缘进程间的同步与互斥、无血缘进程间的同步与互斥。
当信号量值大于 0 时则可以访问否则将阻塞。
PV 原语是对信号量的操作一次 P 操作使信号量减一次 V 操作使信号量加。
号量数据类型为sem_t
信号量用于互斥
不管多少个任务互斥 只需要一个信号量与前面的锁机制相同。先P 任务 再 V 信号量用于同步
有多少个任务 就需要多少个信号量。最先执行的任务对应的信号量为1其他信号量全 部为0。
每任务先P自己 任务 再V下一个任务的信号量 信号量的API
初始化信号量
#include semaphore.h
int sem_init(sem_t *sem, int pshared, unsigned int value)
功能 创建一个信号量并初始化它的值。一个无名信号量在被使用前必须先初始化。
参数 sem信号量的地址 pshared等于 0信号量在线程间共享常用不等于0信号量在进程间共享。 value信号量的初始值
返回值 成功0 失败 - 1
信号量减一 P操作
int sem_wait(sem_t *sem);
功能: 将信号量减一,如果信号量的值为0 则阻塞,大于0可以减一
参数:信号量的地址
返回值:成功返回0 失败返回-1
尝试对信号量减一
int sem_trywait(sem_t *sem);
功能: 尝试将信号量减一,如果信号量的值为0 不阻塞,立即返回 ,大于0可以减一
参数:信号量的地址
返回值:成功返回0 失败返回-1
信号量加一 V操作
int sem_post(sem_t *sem);
功能:将信号量加一
参数:信号量的地址
返回值:成功返回0 失败返回-1
销毁信号量
int sem_destroy(sem_t *sem);
功能: 销毁信号量
参数: 信号量的地址
返回值:成功返回0 失败返回-1
使用场景
信号量用于线程的互斥
#include pthread.h
#include stdio.h
#include semaphore.h
#include unistd.h//定义一个信号量用于互斥
sem_t sem;void my_print(char* str)
{int i0;while(str[i]!\0){printf(%c,str[i]);fflush(stdout);sleep(1);}return;
}void *task_fun(void *arg)
{//P操作sem_wait(sem);my_print((char*)arg);//V操作sem_post(sem);return NULL;
}int main(int argc, char const *argv[])
{//信号量初始化为1sem_init(sem,0,1);pthread_t tid1,tid2,tid3;pthread_create(tid1,NULL,task_fun,hello);pthread_create(tid2,NULL,task_fun,world);pthread_create(tid3,NULL,task_fun,nanjing);pthread_join(tid1,NULL);pthread_join(tid2,NULL);pthread_join(tid3,NULL);//销毁信号量sem_destroy(sem);return 0;
}信号量用于线程的同步
#include pthread.h
#include stdio.h
#include semaphore.h
#include unistd.h//定义一个信号量用于互斥
sem_t sem1,sem2,sem3;void my_print(char* str)
{int i0;while(str[i]!\0){printf(%c,str[i]);fflush(stdout);sleep(1);}return;
}void *task_fun01(void *arg)
{//P操作sem_wait(sem2);my_print((char*)arg);//V操作sem_post(sem3);return NULL;
}void *task_fun02(void *arg)
{//P操作sem_wait(sem3);my_print((char*)arg);//V操作sem_post(sem1);return NULL;
}void *task_fun03(void *arg)
{//P操作sem_wait(sem1);my_print((char*)arg);//V操作sem_post(sem2);return NULL;
}int main(int argc, char const *argv[])
{//信号量初始化为1sem_init(sem1,0,1);sem_init(sem2,0,0);sem_init(sem3,0,0);pthread_t tid1,tid2,tid3;pthread_create(tid1,NULL,task_fun01,hello);pthread_create(tid2,NULL,task_fun02,world);pthread_create(tid3,NULL,task_fun03,nanjing);pthread_join(tid1,NULL);pthread_join(tid2,NULL);pthread_join(tid3,NULL);//销毁信号量sem_destroy(sem1);sem_destroy(sem2);sem_destroy(sem3);return 0;
}无名信号量 用于 血缘关系的进程间互斥
如下图所示通过一个普通的信号量想要实现父子进程间的互斥由于父子进程使用的是独立的代码空间因此当fork后两个进程都会执行PV操作因此这种方法无法实现进程互斥。 我们可以保证信号量是父子进程公共识别的让信号量脱离父子进程空间。我们可以通过磁盘映射、存储映射、内存共享 #include sys/mman.h
#include stdio.h
#include semaphore.h
#include unistd.h
#include sys/wait.hvoid my_print(char *str)
{int i 0;while (str[i] ! \0){printf(%c, str[i]);fflush(stdout);sleep(1);}return;
}int main(int argc, char const *argv[])
{//定义一个无名信号量// MAP_ANONYMOUS匿名映射不使用文件描述符fd为-1表示不需要文件描述符sem_t *sem mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);//无名信号量的初始化 参数21表示进程sem_init(sem, 1, 1);pid_t pid fork();if (pid 0) //子进程{// P操作sem_wait(sem);my_print(hello);// V操作sem_post(sem);}else if (pid 0) //父进程{// P操作sem_wait(sem);my_print(world);// V操作sem_post(sem);int status 0;pid_t pid wait(status);}//销毁信号量sem_destroy(sem);
}无名信号量 用于 血缘关系的进程间同步
进程间的同步需要用到两个信号量
#include sys/mman.h
#include stdio.h
#include semaphore.h
#include unistd.h
#include sys/wait.hvoid my_print(char *str)
{int i 0;while (str[i] ! \0){printf(%c, str[i]);fflush(stdout);sleep(1);}return;
}int main(int argc, char const *argv[])
{//定义一个无名信号量// MAP_ANONYMOUS匿名映射不使用文件描述符fd为-1表示不需要文件描述符sem_t *sem1 mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);sem_t *sem2 mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);//无名信号量的初始化 参数21表示进程sem_init(sem1, 1, 1);sem_init(sem2, 1, 0);pid_t pid fork();if (pid 0) //子进程{// P操作sem_wait(sem1);my_print(hello);// V操作sem_post(sem2);}else if (pid 0) //父进程{// P操作sem_wait(sem2);my_print(world);// V操作sem_post(sem1);int status 0;pid_t pid wait(status);}//销毁信号量sem_destroy(sem1);sem_destroy(sem2);
}有名信号量 用于 无血缘的进程间互斥
有名信号量的使用类似于文件操作有名信号量创建完成之后当前整个系统有效直到系统重启或通过sem_unlink函数手动删除。
创建一个有名信号量
创建并初始化有名信号量或打开一个已存在的有名信号量。
注 如果指定了O_CREAT而没有指定O_EXCL那么只有所需的信号量尚未存在时才初始化他。 如果所需的信号量已经存在mode,value都会被忽略。
#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);
功能 创建一个信号量
参数 name:信号量的名字 oflag:sem_open函数的权限标志 mode:文件权限可读、可写、可执行 0777的设置 value:信号量的初始值
返回值 信号量的地址失败SEM_FAILED
信号量的关闭
int sem_close(sem_t *sem);
功能关闭信号量
参数信号量的的地址
返回值成功0 失败-1
信号量文件的删除
#include semaphore.h
int sem_unlink(const char *name);
功能删除信号量的文件
参数信号量的文件名
返回值成功0 失败-1
案例完成互斥
TaskA.c
#include stdio.h
#include semaphore.h
#include sys/stat.h
#include unistd.h
#include fcntl.hvoid my_print(char *str)
{int i 0;while (str[i] ! \0){printf(%c, str[i]);fflush(stdout);sleep(1);}return;
}int main(int argc, char const *argv[])
{//创建一个有名信号量sem_open类似文件操作 最后一个参数为初始值sem_t *sem sem_open(sem,O_RDWR|O_CREAT,0666,1);//P 操作sem_wait(sem);//任务my_print(hello world);//V 操作sem_post(sem);//关闭信号量sem_close(sem);//销毁信号量sem_destroy(sem);return 0;
}
TaskB.c
#include stdio.h
#include semaphore.h
#include sys/stat.h
#include unistd.h
#include fcntl.hvoid my_print(char *str)
{int i 0;while (str[i] ! \0){printf(%c, str[i]);fflush(stdout);sleep(1);}return;
}int main(int argc, char const *argv[])
{//创建一个有名信号量sem_open类似文件操作 最后一个参数为初始值sem_t *sem sem_open(sem,O_RDWR|O_CREAT,0666,1);//P 操作sem_wait(sem);//任务my_print(nanjing 8.20);//V 操作sem_post(sem);//关闭信号量sem_close(sem);//销毁信号量sem_destroy(sem);return 0;
}
运行效果先运行A再运行B。A关闭有名信号量前B无法打开有名信号量阻塞 有名信号量 用于 无血缘的进程间同步
TaskA.c
#include stdio.h
#include semaphore.h
#include sys/stat.h
#include unistd.h
#include fcntl.hvoid my_print(char *str)
{int i 0;while (str[i] ! \0){printf(%c, str[i]);fflush(stdout);sleep(1);}return;
}int main(int argc, char const *argv[])
{//创建一个有名信号量sem_open类似文件操作 最后一个参数为初始值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);//任务my_print(hello world);//V 操作sem_post(sem2);//关闭信号量sem_close(sem1);sem_close(sem2);//销毁信号量sem_destroy(sem1);sem_destroy(sem2);return 0;
}
TaskB.c
#include stdio.h
#include semaphore.h
#include sys/stat.h
#include unistd.h
#include fcntl.hvoid my_print(char *str)
{int i 0;while (str[i] ! \0){printf(%c, str[i]);fflush(stdout);sleep(1);}return;
}int main(int argc, char const *argv[])
{//创建一个有名信号量sem_open类似文件操作 最后一个参数为初始值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);//任务my_print(nanjing 8.20);//V 操作sem_post(sem1);//关闭信号量sem_close(sem1);sem_close(sem2);//销毁信号量sem_destroy(sem1);sem_destroy(sem2);return 0;
}
