信号量：来源于美国铁路调度。
原语：原子操作。操作是完整的。没有人打断。
现在都是用system V 信号量。
semaphore:信号量、信号灯
微指令：指令集。
手机是arm处理器。
i++; //做加法的时候，需要保护
信号量同共享内存一样，不会随着进程的结束而消失。
key_t ftok(const char *pathname, int proj_id);
//产生key。proj_id通常传入一非0字符。
int semget(key_t key,int nsems,int flag);
//创建或获取相应的信号量。返回信号量集ID。nsems=1表示1个信号量。
int semop(int semid,struct sembuf *sops,size_t num_sops);
//函数semop用于改变信号量对象中各个信号量的状态。sops是一个 结构体数组指针。num_sops表示数组元素个数。结构体数组传进
来的
时候弱化为指针，
所
以
需要一个变量来说明数组元素的个数。即将要操 作的信号量的个数。struct sembuf结
构体如下所示。semop()函数是一
个原子操作。
int semctl(int semid, int semnum, int cmd, …);
//
cmd通常为：IPC_RMID、GETVAL、SETVAL、GETALL、SETALL。semnum为 信号量集中的信号量的编号，第一个信号量为0.
IPC_RMID:立即删除信号集，唤醒所有被阻塞的进程
SETVAL :根据semun设定信号的值，从0开始，第一个信号量编号为0
GETVAL :根据semun返回信号量的值，从0开始，第一个信号量编号为0 GETALL :获取所有信号量的值,第二个参数为0，将所有信号的值存入semun.array中 SETALL :将所有semun.array的值设定到信号集中，第二个参数为0.
struct sembuf{
short sem_num; //操作信号量在信号量集合中的编号，第一个信号量的编号是0。
short sem_op; //sem_op成员的值是信号量在一次操作中需要改变的数值。
通常只会用到两个值，一个是-1，也就是p操作，
它等
待信号量变为可用；一个是+1，也就是v操作，它发送信号通知信号量现在可用。
short sem_flg; //通常设为：
SEM_UNDO，程序结束，信号量为semop调用前的值。防止对信号量-1了之后，没有+1就退出 了，他人都在等你。
};
例子1：
int main(){
int semid=
semget((key_t)1234,
1,IPC_CREAT|0600);
//信号量跟共享内存一样，不会随着进程的结束而消失。1表示创建一 个信号量。创建完成后,用ipcs命令可以看到：信号量集的ID以及该信号 量集有几个信号量。
if(-1==semid){
perror("semget");
return -1;
}
int ret=
semctl(semid,0,
SETVAL,1);
//SETVAL表示要设定信号量的值。semid是信号量集ID。0表示信号量集中的
第一个信号量。将第一个信号量的值设为1.信号量只能设置成正值。
if(-1==ret){
perror("semctl");
return -1;
}
ret=
semctl(semid,0,
GETVAL);
//GETVAL表示获取信号量的值。semid是信号量集ID。0为第一个信号。
printf("ret=%d\n",ret);
return 0;
}
例2：创建多个信号量：
//创建一个信号量集合，集合中含有多个信号量
int main(){
int semid=semget((key_t)1234,
2,IPC_CREAT|0600);
//创建信号量集，返回信号量集ID。里面含有2个信号量。
if(-1==semid){
perror("semget");
return -1;
}
unsigned short array[2]={1,2};
int ret=semctl(semid,0,
SETALL,array);
//cmd填SETALL,可以设置所有的信号量。填了SETALL,第二个参数没用。
if(-1==ret){
perror("semctl");
return -1;
}
memset(array,0,sizeof(array));
ret=semctl(semid,0,
GETALL,array);
//会重新放到array
if(-1==ret){
perror("semctl1");
return -1;
}
printf("array[0]=%d,array[1]=%d\n",array[0],array[1]);
//打印出1，2
ret=semctl(semid,0,
IPC_RMID); 信号量集合删除：IPC_RMID
if(-1==ret){
perror("semctl");
return -1;
}
return 0;
}
例子3：
第一步：vim zero.c
//创建共享内存，给共享内存的第一个int型数据赋初值0
int main(){
int shmid=shmget((key_t)1234,20,IPC_CREAT|0600);
if(-1==shmid){
perror("shmget");
return -1;
}
int* i;
i=(int*)shmat(shmid,NULL,0);
*i=0;
//修改i的值为0.
printf("%d\n",*i);
return 0;
}
第二步：vim add1.c
vim add2.c
|
add1.c
int main(){
int shmid=shmget((key_t)1234,20,IPC_CREAT|0600);
if(-1==shmid){
perror("shmget");
return -1
}
int* i;
i=(int*)shmat(shmid,NULL,0);
//连接共享内存
int j;
int
semid=
semget((key_t)1234,1,IPC_CREAT|0600);
int ret=
semctl(semid,0,SETVAL,1); //给信号量赋初值1
if(-1==ret){
perror("semctl");
return -1;
}
struct sembuf sp;
//定义p操作的结构体sp。
memset(&sp,0,sizeof(sp));
sp.sem_num=0;
//第一个信号量编号为0.
sp.sem_op=-1;
//信号量在一次操作中需要-1.
sp.sem_flg=SEM_UNDO;
struct sembuf sv; //定义v操作的结构体sv
memset(&sv,0,sizeof(sv));
sv.sem_num=0;
//第一个信号量
sv.sem_op=1;
//在一次操作中需要+1.
sv.sem_flg=SEM_UNDO;
for(j=0;j<20000000;j++){
semop(semid,&sp,1);
//传入sp[],数组元素个数1.
(*i)++;
semop(semid,&sv,1);
}
return 0;
}
|
add2.c
int main(){
int shmid=shmget((key_t)1234,20,IPC_CREAT|0600);
if(-1==shmid){
perror("shmget");
return -1;
}
int* i;
i=(int*)shmat(shmid,NULL,0);
int j;
int semid=semget((key_t)1234,1,IPC_CREAT|0600);
int ret=semctl(semid,0,SETVAL,1);
if(-1==ret){
perror("semctl");
return -1;
}
struct sembuf sp;
memset(&sp,0,sizeof(sp));
sp.sem_num=0;
sp.sem_op=-1;
sp.sem_flg=SEM_UNDO;
struct sembuf sv;
memset(&sv,0,sizeof(sv));
sv.sem_num=0;
sv.sem_op=1;
sv.sem_flg=SEM_UNDO;
for(j=0;j<20000000;j++){
semop(semid,&sp,1);
(*i)++;
semop(semid,&sv,1);
}
return 0;
}
|
注：信号量有信号量队列，共享内存有共享内存队列。所以用同一个key没有关系。
如果没有用信号量，在加法器中第一个进程从寄存器中取到n,然后加1操作，本来应该返回n+1之后，再从寄存器取出n+1，再加1。但是由于进程的并发，有可能还没有返回n+1。另一个进程就从寄存器中取数去加1了。
第三步：vim Makefile: //方便编译
add1:add1.c add2.c
gcc add1.c -o add1
gcc add2.c -o add2
.PHONY:clean
clean:
rm add1 add2
第四步：vim printf.c //输出最后的值
int main(){
int shmid=shmget((key_t)1234,20,IPC_CREAT|0600);
if(-1==shmid){
perror("shmget");
return -1;
}
int* i;
i=(int*)shmat(shmid,NULL,0);
printf("%d\n",*i);
return 0;
}
第五步:vim start.sh
./add1 &
//把add1放到后台执行。这样就可以马上执行add2。
./add2
第六步：执行
./zero
make
./start.sh
./printf
有后台执行程序时，ctrl +c 之后先ps-elf看看
命令：
ipcs 查看信号量
ipcrm -s semid 删除信号量集合
会立即执行。并把阻塞在当前信号量的进程唤醒。
ret=semctl(semid,0,IPC_RMID);
if(-1==ret){
perror;
}
例4：获取信号量集合的属性，并进行一些设置。
struct semid_ds {
struct ipc_perm sem_perm; //Ownership and permissions
time_t sem_otime; //Last semop time
time_t sem_ctime; //Last change time
unsigned long sem_nsems; // No. of semaphores in set
};
struct ipc_perm {
key_t __key; //Key supplied to semget(2)
uid_t uid; //Effective UID of owner
gid_t gid; //Effective GID of owner
uid_t cuid; //Effective UID of creator
gid_t cgid; //Effective GID of creator
unsigned short mode; //Permissions
unsigned short __seq; //Sequence number
};
int main(){
int semid=semget((key_t)1234,2,IPC_CREAT|0600);
if(-1==semid){
perror("semget");
return -1;
}
struct semid_ds buf;
memset(&buf,0,sizeof(buf));
int ret=semctl(semid,0,
IPC_STAT,&buf);
if(-1==ret){
perror("semctl");
return -1;
}
printf("uid=%d,cuid=%d,mode=%o,nsems=%ld\n",buf.sem_perm.uid,buf.sem_perm.cuid,buf.sem_perm.mode,buf.sem_nsems);
return 0;
}
例5：生产者、消费者问题
生产者进程：
int set_val(int semid){
unsigned short array[2]={0,10};
//第一个信号量是：full，第二个信号量是empty
int ret=semctl(semid,0,
SETALL,
array);
//给信号量设初值：0，10 。这一步不能少，即使只有一个信号量。
if(-1==ret){
perror("semctl");
return -1;
}
memset(array,0,sizeof(array));
ret=semctl(semid,0,GETALL,array);
if(-1==ret){
perror("semctl1");
return -1;
}
printf("array[0]=%d,array[1]=%d\n",array[0],array[1]);
//打印出来看看
}
int main(){
int semid=semget((key_t)1234,
2,IPC_CREAT|0600);
//打开或创建信号量集，返回信号量集ID，信号量集中有2个信号。
if(-1==semid){
perror("semget");
return -1;
}
set_val(semid);
//调用函数，给信号量设初值
struct sembuf sp[2];
//每个结构体代表一个信号，这个结构体中有这个信号的编号及信号的操作，这都是需要单独设置
的。
semop函数只做一件事：从哪个信号开始执行操作，操作几个。会把这几个结构体的操作都执行一遍。
sp[0].sem_num=0;
//sp[0]=full。sp[1]=empty。
sp[0].sem_op=1; //v(full)
sp[0].sem_flg=SEM_UNDO;
sp[1].sem_num=1;
sp[1].sem_op=-1; //p(empty)
sp[1].sem_flg=SEM_UNDO;
while(1){
printf("product num=%d,space num=%d\n",semctl(semid,0,GETVAL),semctl(semid,1,GETVAL));
semop(semid,&sp[1],1);
//semid是信号量集的ID。1表示将要对1个信号量进行操作。这句话的意思是：对semid这个信
号集
中的从sp[1]开始的1个信号量进行操作。生产者：p(empty).
printf("I will produce\n");
semop(semid,&sp[0],1); //v(full)
printf("product num=%d,space num=%d\n",semctl(semid,0,GETVAL),semctl(semid,1,GETVAL));
sleep(2);
}
return 0;
}
消费者进程：
int main(){
int semid=semget((key_t)1234,2,IPC_CREAT|0600);
if(-1==semid){
perror("semget");
return -1;
}
struct sembuf sp[2];
sp[0].sem_num=0;
sp[0].sem_op=-1; //p(full)
sp[0].sem_flg=SEM_UNDO;
sp[1].sem_num=1;
sp[1].sem_op=1; //v(empty)
sp[1].sem_flg=SEM_UNDO;
while(1){
printf("product num=%d,space num=%d\n",semctl(semid,0,GETVAL),semctl(semid,1,GETVAL));
semop(semid,&sp[0],1); //p(full)
printf("I will eat\n");
semop(semid,&sp[1],1); //v(empty)
printf("product num=%d,space num=%d\n",semctl(semid,0,GETVAL),semctl(semid,1,GETVAL));
sleep(3);
}
return 0;
}