semgetvalue函数

1、如果信号量的当前值为-4，则表示系统中在该信号量上有 ？ 个等待进程？谢谢

表示有4个等待进程。

信号量的当前值如果是正值N，该值表示有N个可用资源。

如果为0，则表示所有资源全部被分配，同时没有进程处于等待状态

如果为负数N，则表示全部资源分配完毕，且还有N个进程处于等待该资源的状态。

例如：若信号S的初值为3,当前值为-2,则表示有( 2 )个等待进程，当信号量的值小于0时，其绝对值表示系统中因请求该类资源而被阻塞的进程个数。

(1)semgetvalue函数扩展资料：

参数nsems是一个大于等于0的值，用于指明该信号量集中可用资源数（在创建一个信号量时）。当打开一个已存在的信号量集时该参数值为0。函数执行成功，则返回信号量集的标识符（一个大于等于0的整数），失败，则返回–1。函数semop用以操作一个信号量集，函数原型如下：

#include <sys/sem.h>

int semop( int semid, struct sembuf semoparray[], size_t nops );

函数中参数semid是一个通过semget函数返回的一个信号量标识符，参数nops标明了参数semoparray所指向数组中的元素个数。

2、用信号量描述象棋的执行

信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。为了完成这个过程，需要创建一个信号量VI，然后将Acquire Semaphore VI以及Release Semaphore VI分别放置在每个关键代码段的首末端。确认这些信号量VI引用的是初始创建的信号量。

描述
编辑
以一个停车场的运作为例。简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆直接进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一辆车离开停车场，看门人得知后，打开车拦，放入外面的一辆进去，如果又离开两辆，则又可以放入两辆，如此往复。
在这个停车场系统中，车位是公共资源，每辆车好比一个线程，看门人起的就是信号量的作用。

分类
编辑
整型信号量（integer semaphore)：信号量是整数
记录型信号量（record semaphore)：每个信号量s除一个整数值s.value（计数）外，还有一个进程等待队列s.L，其中是阻塞在该信号量的各个进程的标识
二进制信号量(binary semaphore)：只允许信号量取0或1值
每个信号量至少须记录两个信息：信号量的值和等待该信号量的进程队列。它的类型定义如下：（用类PASCAL语言表述）
semaphore = record
value: integer;
queue: ^PCB;
end;
其中PCB是进程控制块，是操作系统为每个进程建立的数据结构。
s.value>=0时，s.queue为空；
s.value<0时，s.value的绝对值为s.queue中等待进程的个数；

特性
编辑
抽象的来讲，信号量的特性如下：信号量是一个非负整数（车位数），所有通过它的线程/进程（车辆）都会将该整数减一（通过它当然是为了使用资源），当该整数值为零时，所有试图通过它的线程都将处于等待状态。在信号量上我们定义两种操作： Wait（等待） 和 Release（释放）。当一个线程调用Wait操作时，它要么得到资源然后将信号量减一，要么一直等下去（指放入阻塞队列），直到信号量大于等于一时。Release（释放）实际上是在信号量上执行加操作，对应于车辆离开停车场，该操作之所以叫做“释放”是因为释放了由信号量守护的资源。

操作方式
编辑
对信号量有4种操作(include<semaphore>)：
1. 初始化（initialize），也叫做建立（create） int sem_init(sem_t *sem, int pshared, unsigned int value);
2. 等信号（wait），也可叫做挂起（suspend）int sem_wait(sem_t *sem);
3. 给信号（signal）或发信号（post） int sem_post（sem_t *sem）;
4.清理（destroy） int sem_destory(sem_t *sem);[1]

创建
编辑
同共享内存一样，系统中同样需要为信号量集定制一系列专有的操作函数（semget，semctl等）。系统命令ipcs可查看当前的系统IPC的状态，在命令后使用-s参数。使用函数semget可以创建或者获得一个信号量集ID，函数原型如下：
#include <sys/shm.h>
int semget( key_t key, int nsems, int flag);
函数中参数key用来变换成一个标识符，每一个IPC对象与一个key相对应。当新建一个共享内存段时，使用参数flag的相应权限位对ipc_perm结构中的mode域赋值，对相应信号量集的shmid_ds初始化的值如表1所示。
shmid_ds结构初始化值表

ipc_perm结构数据

初 值

ipc_perm结构数据

初 值

Sem_otime

0

Sem_nsems

Nsems

Sem_ctime

系统当前值
　 　

参数nsems是一个大于等于0的值，用于指明该信号量集中可用资源数（在创建一个信号量时）。当打开一个已存在的信号量集时该参数值为0。函数执行成功，则返回信号量集的标识符（一个大于等于0的整数），失败，则返回–1。函数semop用以操作一个信号量集，函数原型如下：
#include <sys/sem.h>
int semop( int semid, struct sembuf semoparray[], size_t nops );
函数中参数semid是一个通过semget函数返回的一个信号量标识符，参数nops标明了参数semoparray所指向数组中的元素个数。参数semoparray是一个struct sembuf结构类型的数组指针，结构sembuf来说明所要执行的操作，其定义如下：
struct sembuf{
unsigned short sem_num;
short sem_op;
short sem_flg;
}
在sembuf结构中，sem_num是相对应的信号量集中的某一个资源，所以其值是一个从0到相应的信号量集的资源总数（ipc_perm.sem_nsems）之间的整数。sem_op指明所要执行的操作，sem_flg说明函数semop的行为。sem_op的值是一个整数，如表2所示，列出了详细sem_op的值及所对应的操作。
sem_op值详解

Sem_op

操 作

正数

释放相应的资源数，将sem_op的值加到信号量的值上

0

进程阻塞直到信号量的相应值为0，当信号量已经为0，函数立即返回。如果信号量的值不为0，则依据sem_flg的IPC_NOWAIT位决定函数动作。sem_flg指定IPC_NOWAIT，则semop函数出错返回EAGAIN。sem_flg没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生。信号量值为0，将信号量的semzcnt的值减1，函数semop成功返回；此信号量被删除（只有超级用户或创建用户进程拥有此权限），函数smeop出错返回EIDRM；进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR

负数

请求sem_op的绝对值的资源。如果相应的资源数可以满足请求，则将该信号量的值减去sem_op的绝对值，函数成功返回。当相应的资源数不能满足请求时，这个操作与sem_flg有关。sem_flg指定IPC_NOWAIT，则semop函数出错返回EAGAIN。sem_flg没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：当相应的资源数可以满足请求，该信号的值减去sem_op的绝对值。成功返回；此信号量被删除（只有超级用户或创建用户进程拥有此权限），函数smeop出错返回EIDRM：进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR

基本流程
编辑
下面实例演示了关于信号量操作的基本流程。程序中使用semget函数创建一个信号量集，并使用semop函数在这个信号集上执行了一次资源释放操作。并在shell中使用命令查看系统IPC的状态。
（1）在vi编辑器中编辑该程序。
程序清单14-10 create_sem.c 使用semget函数创建一个信号量
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
int main( void )
{
int sem_id;
int nsems = 1;
int flags = 0666;
struct sembuf buf;
sem_id = semget(IPC_PRIVATE, nsems, flags); /*创建一个新的信号量集*/
if ( sem_id < 0 ){
perror( "semget ") ;
exit (1 );
}
/*输出相应的信号量集标识符*/
printf ( "successfully created a semaphore : %d\n", sem_id );
buf.sem_num = 0; /*定义一个信号量操作*/
buf.sem_op = 1; /*执行释放资源操作*/
buf.sem_flg = IPC_NOWAIT; /*定义semop函数的行为*/
if ( (semop( sem_id, &buf, nsems) ) < 0) { /*执行操作*/
perror ( "semop");
exit (1 );
}
system ( "ipcs -s " ); /*查看系统IPC状态*/
exit ( 0 );
}
（2）在vmware中编译该程序如下：
gcc -o a.o testc_semaphore.c
（3）在shell中运行该程序如下：
./a3.o
successfully created a semaphore : 0
------ Semaphore Arrays --------
key semid owner perms nsems
0x00000000 0 zcr 666 1
在上面程序中，用semget函数创建了一个信号量集，定义信号量集的资源数为1，接下来使用semop函数进行资源释放操作。在程序的最后使用shell命令ipcs来查看系统IPC的状态。
%注意：命令ipcs参数-s标识查看系统IPC的信号量集状态。

希望能帮到你，满意望采纳哦。

3、linux进程间通信问题 我想用共享内存的方式实现信号量控制一个不许并行的的函数 请问下面我的代码合理吗

我想你的目的是有一段代码 （即你标的 /*..........只能单独进行的函数.........*/）
在任意时刻最多只能有最多一个进程执行，是吧。

首先，你的做法是错的…… 简单的说，原因是由于
while( *shmaddr );
*shmaddr = 1;
这两行代码不是一个原子操作，从while判断出 *shmaddr等于0 到 *shmaddr=1 之间，另外一个或多个进程可能也会得到 *shmaddr==0 的判断，从而导致多个进程同时进入 /*..........只能单独进行的函数.........*/
具体关于互斥的基本原理，以及你为什么错，可以找一本讲操作系统原理 （关于进程同步的内容）去看。

所以，用 shared memory 来实现进程同步肯定是不行的，正确的做法是使用 semaphore, 具体可以参考 《unix 环境高级编程》中关于 semaphore (信号量）使用的章节。

4、函数key(lkey1=ftok("/etc/profile",1)里的第二个参数项目ID具体是指什么含义

DESCRIPTION
The ftok() function uses the identity of the file named by the given pathname (which must refer to an existing, accessible file) and the least signifi-
cant 8 bits of proj_id (which must be non-zero) to generate a key_t type System V IPC key, suitable for use with msgget(2), semget(2), or shmget(2).

The resulting value is the same for all pathnames that name the same file, when the same value of proj_id is used. The value returned should be differ-
ent when the (simultaneously existing) files or the project IDs differ.

大概意思是根据前面字符串和后面的字节固定那么返回结果就固定，任何一个值不同返回都可能不同，但无论如何不能保证返回的KEY在系统中没有被使用。

5、使用信号量实现有限缓冲区的生产者和消费者问题（使用fork(),semget()等函数，能在GCC下运行）

看我下面的代码， 父进程是消费者，子进程是生产者。

REPEATS 决定总共生产的次数 （可以自己修改）
CONSUMER_SPEED 决定消费的速度 （越大越慢，可以自己修改）
PRODUCER_SPEED 决定生产的速度 （越大越慢，可以自己修改）

我的例子里，生产者生产一个随机数。另外消费速度比生产速度慢，所以可以看到输出中，+++ （生产者） 开头的出现的比--- （消费者）多，当生产者结束后，就只有 --- 打印了。

对这个程序由什么问题，可以baidu hi我。在linux/unix下用 gcc 编译。

#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/stat.h>

#define REPEATS (10) /* count of proction/consumption */

#define MAX_BUFFER_SIZE (8)

typedef struct
{
int bottom;
int top;

int data[MAX_BUFFER_SIZE];
} STRUCT_BUFFER;

STRUCT_BUFFER * pBuffer = NULL;

/* Define speed of consumer/procer, change them as u like */
#define PRODUCER_SPEED (1) /* 1/sec */
#define CONSUMER_SPEED (2) /* 1/2sec */

int sem_consume; /* consumer sem */
int sem_proce; /* procer sem */
int shm_buffer; /* shared buffer */

#define FLAG (IPC_CREAT | S_IRWXU)

/* Init semphores & shared buffer */
void init()
{
union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
} arg;

shm_buffer = shmget(0x1111, sizeof(STRUCT_BUFFER), FLAG);
pBuffer = shmat(shm_buffer, 0, 0);
memset(pBuffer, 0, sizeof(STRUCT_BUFFER));

sem_consume = semget(0x2222, 1, FLAG);
arg.val = 0;
if (semctl(sem_consume, 0, SETVAL, arg) < 0)
{
perror("Consumer");
exit(1);
}

sem_proce = semget(0x3333, 1, FLAG);
arg.val = MAX_BUFFER_SIZE;
if (semctl(sem_proce, 0, SETVAL, arg) < 0)
{
perror("Procer");
exit(1);
}
}

/* destroy semphores & shared buffer */
void deinit()
{
shmctl(shm_buffer, IPC_RMID, NULL);
semctl(sem_consume, 0, IPC_RMID);
semctl(sem_proce, 0, IPC_RMID);
}

int main()
{
int pid, i;
struct sembuf sbuf;

init();

printf("Start fork...\n");
pid = fork();

if (pid > 0)
{
/* parent process, consumer */
for (i = 0; i < REPEATS; i++)
{
/* Try decrementing 1 from consumer */
sbuf.sem_num=0;
sbuf.sem_op=-1;
sbuf.sem_flg=0;
semop(sem_consume, &sbuf, 1);

/* OK */
printf("Consumer get %6d\n", pBuffer->data[pBuffer->bottom]);
pBuffer->bottom = (pBuffer->bottom+1)%MAX_BUFFER_SIZE;

/* Try incrementing 1 to procer */
sbuf.sem_op = 1;
semop(sem_proce, &sbuf, 1);

sleep(CONSUMER_SPEED);
}
wait(0);
shmdt(pBuffer);
}
else if (pid == 0)
{
srand(time(NULL));
/* child process, procer */
for (i = 0; i < REPEATS; i++)
{
/* Try decrementing 1 from procer */
sbuf.sem_num=0;
sbuf.sem_op=-1;
sbuf.sem_flg=0;
semop(sem_proce, &sbuf, 1);

/* OK */
pBuffer->data[pBuffer->top] = (rand()%1000)*1000 + i + 1;
printf("Procer put %6d\n", pBuffer->data[pBuffer->top]);
pBuffer->top = (pBuffer->top+1)%MAX_BUFFER_SIZE;

/* Try incrementing 1 to consumer */
sbuf.sem_op = 1;
semop(sem_consume, &sbuf, 1);

sleep(PRODUCER_SPEED);
}
shmdt(pBuffer);
exit(0);
}

deinit();
return 0;
}

6、unix创建信号灯函数semget怎么用

是的，具体可详细参考APUE(UNIX环境高级编程)的P405，有一个popen()函数的具体实现。APUE电子书可以在网上下载。

7、Linux中semget函数的参数key和函数返回值的作用区别是什么？

key是给内核看的，不同进程用同一个key可以返回一个相同的ID
而返回值是给内核管理用的
二者一一对应，key给应用自由，返回的ID是为了内核管理方便