sem信号量怎么计算

1、linux 怎么查 信号量 被进程p住

sem_init：初始化信号量sem_t，初始化的时候可以指定信号量的初始值，以及是否可以在多进程间共享。
sem_wait：一直阻塞等待直到信号量>0。
sem_timedwait：阻塞等待若干时间直到信号量>0。
sem_post：使信号量加1。
sem_destroy：释放信号量。和sem_init对应。 答案补充 关于各函数的具体参数请用man查看,如man sem_init可查看该函数的帮助

信号量的工作原理
由于信号量只能进行两种操作等待和发送信号，即P(sv)和V(sv),他们的行为是这样的：
P(sv)：如果sv的值大于零，就给它减1；如果它的值为零，就挂起该进程的执行
V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给它加1.

举个例子，就是两个进程共享信号量sv，一旦其中一个进程执行了P(sv)操作，它将得到信号量，并可以进入临界区，使sv减1。而第二个进程将被阻止进入临界区，因为当它试图执行P(sv)时，sv为0，它会被挂起以等待第一个进程离开临界区域并执行V(sv)释放信号量，这时第二个进程就可以恢复执行。

Linux的信号量机制
Linux提供了一组精心设计的信号量接口来对信号进行操作，它们不只是针对二进制信号量，下面将会对这些函数进行介绍，但请注意，这些函数都是用来对成组的信号量值进行操作的。它们声明在头文件sys/sem.h中。

2、计算机*作系统中，若P、V*作的信号量S初值为2，当前值为-1，则表示有____个等待进程

有1个等待进程。

信号量(Semaphore)，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。

为了完成这个过程，需要创建一个信号量VI，然后将Acquire Semaphore VI以及Release Semaphore VI分别放置在每个关键代码段的首末端。初值为2，表示初始时有两个可用的资源。现在为-1，就说明这两个可用资源已经被占用了，有一个进程还在等待资源。

(2)sem信号量怎么计算扩展资料：

对信号量有4种操作(#include<semaphore.h>)：

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)。

3、信号量实现如下程序

#include <stdio.h>
#include <stdlib.h>
#include <prhtread.h>
#include <semaphore.h>
sem_t sem;
void* task(void* p){
sem_wait(&sem);
sleep(1);
sem_post(&sem);
}
int main(){
sem_init(&sem,0,1);
pthread_t id;
int i;
for(i=0;i<10;i++){
phtread_create(&id,0,task,0);
}
sem_destroy(&sem);
}

框架给你，也许，需要你自己填充你需要的内容了。

4、怎么修改linux中sem的值

有3个方法
#在控制台上输入

bash$ mysql -u root mysql

#用mysql客户程序

mysql> UPDATE user SET

5、信号量的使用，求助

信号量：一个整数；
大于或等于0时代表可供并发进程使用的资源实体数；
小于0时代表正在等待使用临界区的进程数；
用于互斥的信号量初始值应大于0；
只能通过P、V原语操作而改变；
信号量元素组成：
1、表示信号量元素的值；
2、最后操作信号量元素的进程ID
3、等待信号量元素值+1的进程数；
4、等待信号量元素值为0的进程数；

二、主要函数

1.1 创建信号量
int semget(
key_t key, //标识信号量的关键字，有三种方法：1、使用IPC——PRIVATE让系统产生，
// 2、挑选一个随机数，3、使用ftok从文件路径名中产生
int nSemes, //信号量集中元素个数
int flag //IPC_CREAT；IPC_EXCL 只有在信号量集不存在时创建
)
成功：返回信号量句柄
失败：返回-1

1.2 使用ftok函数根据文件路径名产生一个关键字
key_t ftok(const char *pathname,int proj_id);
路径名称必须有相应权限

1.3 控制信号量
int semctl(
int semid, //信号量集的句柄
int semnum, //信号量集的元素数
int cmd, //命令
/*union senum arg */... //
)
成功：返回相应的值
失败：返回-1

命令详细说明:
cmd: IPC_RMID 删除一个信号量
IPC_EXCL 只有在信号量集不存在时创建
IPC_SET 设置信号量的许可权
SETVAL 设置指定信号量的元素的值为 agc.val
GETVAL 获得一个指定信号量的值
GETPID 获得最后操纵此元素的最后进程ID
GETNCNT 获得等待元素变为1的进程数
GETZCNT 获得等待元素变为0的进程数

union senum 定义如下：
union senum{
int val;
struct semid_ds *buf;
unsigned short * array;
}agc;
其中 semid_ds 定义如下：
struct semid_ds{
struct ipc_pem sem_pem; //operation pemission struct
time_t sem_otime; //last semop()time
time_t sem_ctime; //last time changed by semctl()
struct sem *sembase; //ptr to first semaphore in array
struct sem_queue *sem_pending; //pending operations
struct sem_queue *sem_pending_last; //last pending operations
struct sem_undo *undo; //undo requests on this arrary
unsigned short int sem_nsems; //number of semaphores in set
};

1.4 对信号量 +1 或 -1 或测试是否为0
int semop(
int semid,
struct sembuf *sops, //指向元素操作数组
unsigned short nsops //数组中元素操作的个数
)

结构 sembuf 定义
sembuf{
short int sem_num; //semaphore number
short int sem_op; //semaphore operaion
short int sem_flg //operation flag
};

三、例子:
2.1 服务器

#include <sys/sem.h>
#include <sys/ipc.h>

#define SEGSIZE 1024
#define READTIME 1
union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
} arg;
//生成信号量
int sem_creat(key_t key)
{
union semun sem;
int semid;
sem.val = 0;
semid = semget(key,1,IPC_CREAT|0666);
if (-1 == semid){
printf("create semaphore error\n");
exit(-1);
}
semctl(semid,0,SETVAL,sem);
return semid;
}
//删除信号量
void del_sem(int semid)
{
union semun sem;
sem.val = 0;
semctl(semid,0,IPC_RMID,sem);
}

//p
int p(int semid)
{
struct sembuf sops={0,+1,IPC_NOWAIT};
return (semop(semid,&sops,1));
}
//v
int v(int semid)
{
struct sembuf sops={0,-1,IPC_NOWAIT};
return (semop(semid,&sops,1));
}
int main()
{
key_t key;
int shmid,semid;
char *shm;
char msg[7] = "-data-";
char i;
struct semid_ds buf;

key = ftok("/",0);
shmid = shmget(key,SEGSIZE,IPC_CREAT|0604);
if (-1 == shmid){
printf(" create shared memory error\n");
return -1;
}
shm = (char *)shmat(shmid,0,0);
if (-1 == (int)shm){
printf(" attach shared memory error\n");
return -1;
}
semid = sem_creat(key);
for (i = 0;i <= 3;i++){
sleep(1);
p(semid);
sleep(READTIME);
msg[5] = '0' + i;
memcpy(shm,msg,sizeof(msg));
sleep(58);
v(semid);
}
shmdt(shm);
shmctl(shmid,IPC_RMID,&buf);
del_sem(semid);
return 0;
//gcc -o shm shm.c -g
}

2.2 客户端

#include <sys/sem.h>
#include <time.h>
#include <sys/ipc.h>

#define SEGSIZE 1024
#define READTIME 1
union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
} arg;

// 打印程序执行时间
void out_time(void)
{
static long start = 0;
time_t tm;
if (0 == start){
tm = time(NULL);
start = (long)tm;
printf(" now start ...\n");
}
printf(" second: %ld \n",(long)(time(NULL)) - start);
}

//创建信号量
int new_sem(key_t key)
{
union semun sem;
int semid;
sem.val = 0;
semid = semget(key,0,0);
if (-1 == semid){
printf("create semaphore error\n");
exit(-1);
}
return semid;
}

//等待信号量变成0
void wait_v(int semid)
{
struct sembuf sops={0,0,0};
semop(semid,&sops,1);
}

int main(void)
{
key_t key;
int shmid,semid;
char *shm;
char msg[100];
char i;

key = ftok("/",0);
shmid = shmget(key,SEGSIZE,0);

if(-1 == shmid){
printf(" create shared memory error\n");
return -1;
}
shm = (char *)shmat(shmid,0,0);
if (-1 == (int)shm){
printf(" attach shared memory error\n");
return -1;
}
semid = new_sem(key);
for (i = 0;i < 3;i ++){
sleep(2);
wait_v(semid);
printf("Message geted is: %s \n",shm + 1);
out_time();
}
shmdt(shm);
return 0;
// gcc -o shmc shmC.c -g
}

6、多线程编程的原则以及Sem信号量和Mutex互斥锁的区别

以下两种类型：
二值信号量：最简单的信号量形式，信号量的值只能取0或1，类似于互斥锁。
注：二值信号量能够实现互斥锁的功能，但两者的关注内容不同。信号量强调共享资源，只要共享资源可用，其他进程同样可以修改信号量的值；互斥锁更强调进程，占用资源的进程使用完资源后，必须由进

7、在ucos中创建一个信号量 比如ossemcreat（0）。ossemcreat（1）的区别

OSSemPost 和OSSemPend是成对出现的，在程序OSSemPost 尚未运行到的时候，在等待Sem的
OSSemPend是会把当前的任务挂起，直到另外一个任务的OSSemPost 运行完毕都得到Sem。但是可以通过改变OSSemCreate(x)里面的值x改变这种局面，当x不为0时，OSSemPend会马上得到Sem继续运行当前任务至结束，并将x的数值减一，直到为0。为0后，只有等其他任务的OSSemPost了。