信号量相关功能
一、信号量的概念
1.线程的信号量是一种特殊的变量，它可以被增加或减少，但对其的关键访问被保证是原子操作。如果一个程序中有多个线程试图改变一个信号量的值，系统将保证所有的操作都将依次进行。但如果是普通变量，来自同一程序中不同线程的冲突操作所导致的结果将是不确定的。信号量一般常用于保护一段代码，使其每次只被一个执行线程运行。信号量是用来调协线程对共享资源的访问的。
2.最简单的信号量是二进制信号量，它只有0和1两种取值。还有更通用的信号量——计数信号量，它可以有更大的取值范围。信号量一般常用来保护一段代码，使其每次只能被一个执行线程运行，要完成这个工作，就要使用二进制信号量。有时，我们希望可以允许有限数目的线程执行一段指定的代码，这就需要计数信号量。
3. 信号量控制资源共享主要是PV原语操作， PV原语是对整数计数器信号量sem的操作。一次P操作使sem减一，而一次V操作使sem加一。进程（或线程）根据信号量的值来判断是否对公共资源具有访问权限。当信号量sem的值大于等于零时，该进程（或线程）具有公共资源的访问权限；相反，当信号量sem的值小于零时，该进程（或线程）就将阻塞直到信号量sem的值大于等于0为止。
- 信号量从本质上是一个非负整数计数器，是共享资源的数目，通常被用来控制对共享资源的访问
- 信号量可以实现线程的同步和互斥
- 通过 sem_post() 和 sem_wait() 函数对信号量进行加减操作从而解决线程的同步和互斥
- 信号量数据类型：sem_t
二、信号量与互斥量的区别联系
在Linux中有两种方法用于处理线程同步：信号量和互斥量。
通过使用信号量可以很好的完成线程同步。两个线程同时监视同一个信号量。A线程增加信号量的值，B线程减少信号量的值。当A线程增加信号量大于0时，B线程的等待信号量就会触发，每触发一次将信号量减1，直到将信号量减为0，B线程继续等待A线程增加信号量。
信号量和互斥锁(mutex)的区别：互斥锁只允许一个线程进入临界区，而信号量允许多个线程同时进入临界区。
信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作。而互斥锁是用在多线程多任务互斥的，一个线程占用了某一个资源，那么别的线程就无法访问，直到这个线程unlock，其他的线程才开始可以利用这个资源。比如对全局变量的访问，有时要加锁，操作完了，在解锁。有的时候锁和信号量会同时使用的。
信号量：只要信号量的value大于0，其他线程就可以sem_wait成功，成功后信号量的value减1。若value值不大于0，则sem_wait使得线程阻塞，直到sem_post释放后value值加1,但是sem_wait返回之前还是会将此value值减1.
如果信号量的值大于0表示可用的资源数，小于0表示阻塞的线程数。
互斥锁: 只要被锁住，其他任何线程都不可以访问被保护的资源，也就是说，信号量不一定是锁定某一个资源，而是流程上的概念，比如：有A,B两个线程，B线程要等A线程完成某一任务以后再进行自己下面的步骤，这个任务并不一定是锁定某一资源，还可以是进行一些计算或者数据处理之类。而线程互斥量则是“锁住某一资源”的概念，在锁定期间内，其他线程无法对被保护的数据进行操作。在有些情况下两者可以互换。
两种信号量：二进制信号量和计数信号量。二进制信号量只有0和1两种取值，而计数信号量则有更大的取值范围。如果某个共享资源只能被一个线程访问，那么二进制信号量则是最好的打算；如果有多个线程需要访问共享资源呢，使用计数信号量则是个好的主意。
互斥锁只有0，1两中状态，适合于线程对共享资源的独占访问，很多时候每个资源可以同时被有限的线程访问，此时互斥锁将无法满足；条件变量同步也同样存在这种问题。信号量实际是一种非负整型计数器，可以很好的控制线程之间资源访问，互斥锁能实现的功能，信号量同样可以。
三、信号的使用
1.信号量的创建和销毁
#include<semaphore.h>
int sem_init(sem_t *sem,int pshared,unsigned value);
int sem_destory(sem_t *sem);
-
返回：成功返回0,出错返回错误编号
-
参数：
- sem信号量指针
- pthread是否在进程间共享的标志，0为不共享，1为共享
- value初始的时候信号量值
sem_init(sem_t*sem, int pshared, unsigned int value)：该函数用于创建信号量。初始化一个定位在sem的匿名信号量。value参数指定信号量的初始值。pshared参数指明信号量是由进程内线程共享，还是由进程之间共享。如果pshared的值为0，那么信号量将被进程内的线程共享，并且应该放置在所有线程都可见的地址上(如全局变量，或者堆上动态分配的变量)。
sem_destroy：该函数用于对用完的信号量的清理。用来释放信号量sem。
2.信号量的加和减操作
#include <semaphore.h>
int sem_wait(sem_t *sem);//相当于p操作，减少信号量的值
int sem_trywait(sem_t *sem);//sem_wait的非阻塞版本，减少信号量的值
int sem_post(sem_t *sem);//相当于v操作,增加信号量的值
- 返回值：成功返回0；出错返回错误编号
- 参数：
- sem信号量指针
- 函数说明：
调用 sem_post() 一次信号量作 +1 操作
调用 sem_wait() 一次信号量作 -1 操作
当线程调用 sem_wait() 后，若信号量的值小于 0 ，则线程阻塞。只有其他线程在调用 sem_post() 对信号量作加操作后，并且其值大于或等于 0 时，阻塞的线程才能继续运行。
sem_wait(sem_t* sem)：该函数用于以原子操作的方式将信号量的值减1。(原子操作就是，如果两个线程企图同时给一个信号量加1或减1，它们之间不会互相干扰。)但它永远会先等待该信号量为一个非零值才开始做减法。也就是说，如果你对一个值为2的信号量调用sem_wait(),线程将会继续执行，这信号量的值将减到1。如果对一个值为0的信号量调用sem_wait()，这个函数就会等待直到有其它线程增加了这个值使它不再是0为止。如果有两个线程都在sem_wait()中等待同一个信号量变成非零值，那么当它被第三个线程增加一个“1”时，等待线程中只有一个能够对信号量做减法并继续执行，另一个还将处于等待状态。被用来阻塞当前线程直到信号量sem的值大于0，解除阻塞后将sem的值减一，表明公共资源经使用后减少。
sem_post(sem_t* sem)：该函数用于以原子操作的方式将信号量的值加1。用来增加信号量的值当有线程阻塞在这个信号量上时，调用这个函数会使其中的一个线程不再阻塞，选择机制同样是由线程的调度策略决定的。它信号量的值加1同时发出信号来唤醒等待的线程。
一般调用原则：
如果当做互斥锁的时候，一般初始化的时候初始化为１，然后对其进行PV操作
如果需要进行同步的时候，一般初始化的时候信号量为０，然后对其进行ＰＶ操作
四、信号量的案例
1.案例1
实现3个线程按照顺序执行，实线程的同步。线程的同步将信号量的值初始化为0，然后进行PV操作。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
/*定义信号量*/
sem_t sem1;
sem_t sem2;
/*定义三个线程运行函数,按先后c b a的顺序运行*/
/*
当线程调用 sem_wait() 后，若信号量的值小于 0 ，则线程阻塞。
只有其他线程在调用 sem_post() 对信号量作加操作后，并且其值大于或等于 0 时，阻塞的 线程才能继续运行
*/
void* a_fn()
{
sem_wait(&sem1);
printf("a_fn running!\r\n");
return 0;
}
void* b_fn()
{
sem_wait(&sem2);
printf("b_fn running!\r\n");
sem_post(&sem1);
return 0;
}
void* c_fn()
{
printf("c_fn running!\r\n");
sem_post(&sem2);
return 0;
}
int main()
{
int err;
pthread_t a,b,c;
/*初始化信号量*/
sem_init(&sem1,0,0);
sem_init(&sem2,0,0);
if((err=pthread_create(&a,NULL,a_fn,NULL))!=0)
{
perror("a_fn create fail\r\n");
}
if((err=pthread_create(&b,NULL,b_fn,NULL))!=0)
{
perror("b_fn create fail\r\n");
}
if((err=pthread_create(&c,NULL,c_fn,NULL))!=0)
{
perror("c_fn create fail\r\n");
}
/*阻塞当前任务*/
pthread_join(a,NULL);
pthread_join(b,NULL);
pthread_join(c,NULL);
/*销毁创建的信号量*/
sem_destroy(&sem1);
sem_destroy(&sem2);
return 0;
}
运行结果如下图：
2.案例2
对银行账户进行PV操作，实现线程间的互斥。
#ifndef __ATM_ACCOUNT_H__
#define __ATM_ACCOUNT_H__
#include <math.h>
#include <malloc.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
/** 账户信息 */
typedef struct {
int code; ///< 银行账户的编码
double balance; ///< 账户余额
/** 建议互斥锁用来锁定一个账户（共享资源），和账户绑定再一起，
* 尽量不设置成全局变量，否则可能出现一把锁去锁几百个账户，导致并发性能降低 */
//pthread_mutex_t mutex; ///< 定义一把互斥锁，用来对多线程操作的银行账户（共享资源）进行加锁
//pthread_rwlock_t rwlock; ///<定义读写锁
//定义线程信号量
sem_t sem;
}atm_Account;
/** 创建账户 */
extern atm_Account *atm_account_Create(int code, double balance);
/** 销毁账户 */
extern void atm_account_Destroy(atm_Account *account);
/** 取款 */
extern double atm_account_Withdraw(atm_Account *account, double amt);
/** 存款 */
extern double atm_account_Desposit(atm_Account *account, double amt);
/** 查看账户余额 */
extern double atm_account_BalanceGet(atm_Account *account);
#endif
#include "atm_account.h"
/** 创建账户 */
atm_Account *atm_account_Create(int code, double balance)
{
atm_Account *account = (atm_Account *)malloc(sizeof(atm_Account));
if(NULL == account) {
return NULL;
}
account->code = code;
account->balance = balance;
/** 对互斥锁进行初始化 */
//pthread_mutex_init(&account->mutex, NULL);
/** 初始化读写锁 */
//pthread_rwlock_init(&account->rwlock, NULL);
/** 初始化线程信号量 */
sem_init(&account->sem, 0, 1);
return account;
}
/** 销毁账户 */
void atm_account_Destroy(atm_Account *account)
{
if(NULL == account){
return ;
}
//pthread_mutex_destroy(&account->mutex);
//pthread_rwlock_destroy(&account->rwlock); ///< 销毁读写锁
/** 销毁线程信号量 */
sem_destroy(&account->sem);
free(account);
}
/** 取款: 成功，则返回取款金额 */
double atm_account_Withdraw(atm_Account *account, double amt)
{
if(NULL == account) {
return 0.0;
}
/** 对共享资源（账户进行加锁） */
//pthread_mutex_lock(&account->mutex);
//pthread_rwlock_wrlock(&account->rwlock); ///< 加写锁
/** P(1) 操作 */
sem_wait(&account->sem);
if(amt < 0 || amt > account->balance) {
//pthread_mutex_unlock(&account->mutex);
//pthread_rwlock_unlock(&account->rwlock); ///< 释放写锁
/** V(1) 操作 */
sem_post(&account->sem);
return 0.0;
}
double balance_tmp = account->balance;
sleep(1);
balance_tmp -= amt;
account->balance = balance_tmp;
//pthread_mutex_unlock(&account->mutex);
//pthread_rwlock_unlock(&account->rwlock); ///< 释放写锁
/** V(1) 操作 */
sem_post(&account->sem);
return amt;
}
/** 存款: 返回存款的金额 */
double atm_account_Desposit(atm_Account *account, double amt)
{
if(NULL == account){
return 0.0;
}
/** 对共享资源（账户进行加锁） */
//pthread_mutex_lock(&account->mutex);
//pthread_rwlock_wrlock(&account->rwlock); ///< 加写锁
/** P(1) 操作 */
sem_wait(&account->sem);
if(amt < 0){
//pthread_mutex_unlock(&account->mutex);
//pthread_rwlock_unlock(&account->rwlock); ///< 释放写锁
/** V(1) 操作 */
sem_post(&account->sem);
return 0.0;
}
double balance_tmp = account->balance;
sleep(1);
balance_tmp += amt;
account->balance = balance_tmp;
//pthread_mutex_unlock(&account->mutex);
//pthread_rwlock_unlock(&account->rwlock); ///< 释放写锁
/** V(1) 操作 */
sem_post(&account->sem);
return amt;
}
/** 查看账户余额 */
double atm_account_BalanceGet(atm_Account *account)
{
if(NULL == account){
return 0.0;
}
/** 对共享资源（账户进行加锁） */
//pthread_mutex_lock(&account->mutex);
//pthread_rwlock_rdlock(&account->rwlock); ///< 上读锁
/** P(1) 操作 */
sem_wait(&account->sem);
double balance_tmp = account->balance;
//pthread_mutex_unlock(&account->mutex);
//pthread_rwlock_unlock(&account->rwlock); ///< 释放写锁
/** V(1) 操作 */
sem_post(&account->sem);
return balance_tmp;
}
3.案例3
利用线程信号量实现线程的同步
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
/*定义全局变量以及信号量*/
typedef struct
{
int Result;//共有资源结果值
sem_t sem;//信号量
}Result;
/*创建两个线程，一个计算结果，一个再完成结果计算后再进行结果的获取*/
void* set_fn(void *arg)
{
Result* r=(Result*)arg;
int i=0;
int sum=0;
for(i=0;i<=100;i++)
{
sum+=i;
}
r->Result=sum;
sem_post(&r->sem);//信号量的V操作，信号量计数值加1
return 0;
}
void* get_fn(void *arg)
{
Result* r=(Result*)arg;
sem_wait(&r->sem);//信号量的P操作，信号量计数值减1
int res=r->Result;
printf("0x%lx,get sum is =%d\r\n",pthread_self(),res);
return 0;
}
int main()
{
int err;
Result r;
r.Result=0;
/*初始化信号量的值，计数值为0*/
sem_init(&r.sem,0,0);
pthread_t get,set;
if((err=pthread_create(&get,NULL,get_fn,(void*)&r))!=0)
{
perror("get_fn create fail\r\n");
}
if((err=pthread_create(&set,NULL,set_fn,(void*)&r))!=0)
{
perror("set_fn create fail\r\n");
}
pthread_join(get,NULL);
pthread_join(set,NULL);
/*销毁信号量*/
sem_destroy(&r.sem);
return 0;
}
扫一扫
451
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
