进程控制程序设计----------（Linux---C）

来源：互联网发布：哈工大大数据编辑：程序博客网时间：2024/06/06 09:03

1、进程是一个具有一定独立功能的程序的一次运行活动。

特点：动态性、并发性、独立性、异步性。

2、进程ID
进程ID（PID)：标识进程的唯一数字
父进程的ID（PPID)
启动进程的用户ID（UID）

3、进程互斥
进程互斥是指当有若干进程都要使用某一共享资源时，任何时刻最多允许一个进程使用，其他要使用该资源的进程必
须等待，直到占用该资源者释放了该资源为止。

4、临界资源
操作系统中将一次只允许一个进程访问的资源称为临界资源。

5、临界区
进程中访问临界资源的那段程序代码称为临界区。为实现对临界资源的互斥访问，应保证诸进程互斥地进入各自的临
界区。

6、进程同步
一组并发进程按一定的顺序执行的过程称为进程间的同步。具有同步关系的一组并发进程称为合作进程，合作进程间互相发送的信号称为消息或事件。

7、进程调度
概念：按一定算法，从一组待运行的进程中选出一个来占有CPU运行。
调度方式：抢占式、非抢占式。

8、调度算法
先来先服务调度算法
短进程优先调度算法
高优先级优先调度算法
时间片轮转法

9、死锁
多个进程因竞争资源而形成一种僵局，若无外力作用，这些进程都将永远不能再向前推进。

10、产生死锁的四个必要条件：
（1）互斥条件：一个资源每次只能被一个进程使用。
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件:进程已获得的资源，在使用完之前，不能强行剥夺。
（4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

进程控制编程

1、获取ID

#include <sys/types.h>

#include <unistd.h>

pid_t getpid(void)

获取本进程ID。

pid_t getppid(void)

获取父进程ID。

例：getpid.c (演示)

#include <stdio.h>#include <unistd.h>#include <stdlib.h>int main(void){printf( "PID = %d\n", getpid() );printf( "PPID = %d\n", getppid() );return 0;}

2、进程创建-fork
#include <unistd.h>
pid_t fork(void)
功能：创建子进程
fork的奇妙之处在于它被调用一次，却返回两次，它可能有三种不同的返回值：
1. 在父进程中，fork返回新创建的子进程的PID；
2. 在子进程中，fork返回0；
3. 如果出现错误，fork返回一个负值

例1：fork1.c（演示）

#include <sys/types.h>#include <unistd.h>main(){pid_t pid;/*此时仅有一个进程*/pid=fork();/*此时已经有两个进程在同时运行*/if(pid<0)printf("error in fork!");else if(pid==0)printf("I am the child process, ID is %d\n",getpid());elseprintf("I am the parent process,ID is %d\n",getpid());}

在pid=fork()之前，只有一个进程在执行，但在这条语句执行之后，就变成两个进程在执行了，这两个进程的共享代码段，将要执行的下一条语句都是if(pid==0)。两个进程中，原来就存在的那个进程被称作“父进程”，新出现的那个进程被称作“子进程”，父子进程的区别在于进程标识符（PID）不同。

进程创建—思考运行结果？

#include <unistd.h>#include <stdio.h>int main(void){pid_t pid;int count=0;pid = fork();count++;printf( “count = %d\n", count );return 0；}

输出：
count = 1
count = 1
count++被父进程、子进程一共执行了两次，为什么count的第二次输出为什么不为2？

子进程的数据空间、堆栈空间都会从父进程得到一个拷贝，而不是共享。在子进程中对count进行加1的操作，并没有
影响到父进程中的count值，父进程中的count值仍然为0。

3、进程创建-vfork
#include <sys/types.h>
#include <unistd.h>
pid_t vfork(void)
功能：创建子进程。

fork PK vfork

区别：

1. fork:子进程拷贝父进程的数据段vfork:子进程与父进程共享数据段2. fork:父、子进程的执行次序不确定vfork:子进程先运行，父进程后运行

进程创建-vfork

#include <unistd.h>#include <stdio.h>int main(void){pid_t pid;int count=0;pid = vfork();count++;printf( “count = %d\n", count );return 0；}

4、exec函数族

exec用被执行的程序替换调用它的程序。
区别：
fork创建一个新的进程，产生一个新的PID。
exec启动一个新程序，替换原有的进程，因此进程的PID不会改变。

（1）#include<unistd.h>int execl(const char * path,const char * arg1, ....)

参数：

path：被执行程序名（含完整路径）。
arg1 – argn: 被执行程序所需的命令行参数，含程序名。以空指针（NULL）结束。

例：execl.c （演示）

#include<unistd.h>main(){execl(“/bin/ls”,”ls”,”-al”,”/etc/passwd”,(char * )0);}

（2）#include<unistd.h>int execlp(const char * path,const char * arg1, …)

参数：

path：被执行程序名（不含路径，将从path环境变量中查找该程序）。
arg1 – argn: 被执行程序所需的命令行参数，含程序名。以空指针（NULL）结束。

例：execlp.c （演示）

#include<unistd.h>main(){execlp(”ls”,”ls”,”-al”,”/etc/passwd”,(char *)0);}

（3）#include<unistd.h>int execv (const char * path, char * const argv[ ])

参数：

path：被执行程序名（含完整路径）。
argv[]: 被执行程序所需的命令行参数数组。

例：execv.c （演示）

#include <unistd.h>main(){char * argv[ ]={“ls”,”-al”,”/etc/passwd”,(char*)0};execv(“/bin/ls”,argv);}

（4）#include <stdlib.h>int system( const char* string )

功能：调用fork产生子进程，由子进程来调用/bin/sh -c string来执行参数string所代表的命令。

例：system.c （演示）

＃include <stdlib.h>void main(){system(“ls -al /etc/passwd”);}

5、进程等待

#include <sys/types.h>#include <sys/wait.h>pid_t wait (int * status)

功能：阻塞该进程，直到其某个子进程退出

例：wait.c (演示)
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
void main()
{
pid_t pc,pr;
pc=fork();
if (pc==0)

{/* 如果是子进程*/
printf(“This is child process with pid of %d\n”,getpid());
sleep(10); /* 睡眠10秒钟*/
}
else if (pc>0)

{/* 如果是父进程*/
pr=wait(NULL); /* 等待*/
printf("I catched a child process with pid of %d\n"),pr);
}
exit(0);
}

进程间通信程序设计-1

1、为什么进程间需要通信？

数据传输：一个进程需要将它的数据发送给另一个进程。
资源共享：多个进程之间共享同样的资源
通知事件：一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有操作，
并能够及时知道它的状态改变。

2、Linux进程间通信（IPC）由以下几部分发展而来：UNIX进程间通信
基于System V进程间通信
POSIX进程间通信

（1）POSIXPOSIX(Portable Operating System Interface)表示可移植操作系统接口。电气和电子工程师协会（Institute of Electrical and ElectronicsEngineers，IEEE）最初开发POSIX 标准，是为了提高UNIX 环境下应用程序的可移植性。然而，POSIX 并不局限于UNIX，许多其它的操作系统，例如DEC OpenVMS 和MicrosoftWindows，都支持POSIX 标准。

（2）System VSystem V，也被称为AT&T System V，是Unix操作系统众多版本中的一支

3、现在Linux使用的进程间通信方式包括：

1、管道（pipe）和有名管道（FIFO）
2、信号（signal）
3、消息队列
4、共享内存
5、信号量
6、套接字（socket）

（1）管道通信
管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。

数据被一个进程读出后，将被从管道中删除，其它读进程将不能再读到这些数据。管道提供了简单的流控制机制，进程试图读空管道时，进程将阻塞。同样，管道已经满时，进程再试图向管道写入数据，进程将阻塞。

管道创建
管道包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者可用于运行于同一系统中的任意两个进程间的通信。

无名管道由pipe（）函数创建：int pipe(int filedis[2])；

当一个管道建立时，它会创建两个文件描述符：filedis[0] 用于读管道， filedis[1] 用于写管道。

管道关闭
关闭管道只需将这两个文件描述符关闭即可，可以使用普通的close函数逐个关闭

示例1、

#include <unistd.h>#include <errno.h>#include <stdio.h>#include <stdlib.h>int main(){int pipe_fd[2];if(pipe(pipe_fd)<0){printf("pipe create error\n");return -1;}elseprintf("pipe create success\n");close(pipe_fd[0]);close(pipe_fd[1]);}

管道读写

管道用于不同进程间通信。通常先创建一个管道，再通过fork函数创建一个子进程，该子进程会继承父进程所创建的管道。

注意事项：必须在系统调用fork( )前调用pipe( )，否则子进程将不会继承文件描述符。

实例分析：pipe_rw.c

#include <unistd.h>#include <sys/types.h>#include <errno.h>#include <stdio.h>#include <string.h>#include <stdlib.h>int main(){int pipe_fd[2];pid_t pid;char buf_r[100];char* p_wbuf;int r_num;memset(buf_r,0,sizeof(buf_r));/*创建管道*/if(pipe(pipe_fd)<0){printf("pipe create error\n");return -1;}/*创建子进程*/if((pid=fork())==0)  //子进程执行序列{printf("\n");close(pipe_fd[1]);//子进程先关闭了管道的写端sleep(2); /*让父进程先运行，这样父进程先写子进程才有内容读*/if((r_num=read(pipe_fd[0],buf_r,100))>0){printf("%d numbers read from the pipe is %s\n",r_num,buf_r);}close(pipe_fd[0]);exit(0);  }else if(pid>0) //父进程执行序列{close(pipe_fd[0]); //父进程先关闭了管道的读端if(write(pipe_fd[1],"Hello",5)!=-1)printf("parent write1 Hello!\n");if(write(pipe_fd[1]," Pipe",5)!=-1)printf("parent write2 Pipe!\n");close(pipe_fd[1]);waitpid(pid,NULL,0); /*等待子进程结束*/exit(0);}return 0;}

（2）命名管道（FIFO）
命名管道和无名管道基本相同，但也有不同点：无名管道只能由父子进程使用；但是通过命名管道，不相关的进程也能交换数据。

创建

#include <sys/types.h>#include <sys/stat.h>int mkfifo(const char * pathname, mode_t mode)

pathname：FIFO文件名
mode：属性（见文件操作章节）

一旦创建了一个FIFO，就可用open打开它，一般的文件访问函数（close、read、write等）都可用于FIFO。

操作

当打开FIFO时，非阻塞标志（O_NONBLOCK）将对以后的读写产生如下影响：
1、没有使用O_NONBLOCK：访问要求无法满足时进程将阻塞。如试图读取空的FIFO，将导致进程阻塞。
2、使用O_NONBLOCK：访问要求无法满足时不阻塞，立刻出错返回，errno是ENXIO。

实例分析：fifo_write.c和fifo_read.c

fifo_write.c代码：

#include <sys/types.h>#include <sys/stat.h>#include <errno.h>#include <fcntl.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#define FIFO_SERVER "/tmp/myfifo"int main(int argc,char** argv){int fd;char w_buf[100];int nwrite;    /*创建有名管道*/if((mkfifo(FIFO_SERVER,O_CREAT|O_EXCL|O_RDWR)<0)&&(errno!=EEXIST))printf("cannot create fifoserver\n");/*打开管道*/fd=open(FIFO_SERVER,O_RDWR|O_NONBLOCK,0);if(fd==-1){    perror("open");exit(1);}/*入参检测*/if(argc==1){printf("Please send something\n");exit(-1);}strcpy(w_buf,argv[1]);/* 向管道写入数据 */if((nwrite=write(fd,w_buf,100))==-1){if(errno==EAGAIN)printf("The FIFO has not been read yet.Please try later\n");}else printf("write %s to the FIFO\n",w_buf);close(fd); //关闭管道return 0;}

fifo_read.c代码：

#include <sys/types.h>#include <sys/stat.h>#include <errno.h>#include <fcntl.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#define FIFO "/tmp/myfifo"int main(int argc,char** argv){char buf_r[100];int  fd;int  nread;printf("Preparing for reading bytes...\n");memset(buf_r,0,sizeof(buf_r));/* 打开管道 */fd=open(FIFO,O_RDONLY|O_NONBLOCK,0);if(fd==-1){perror("open");exit(1);}while(1){memset(buf_r,0,sizeof(buf_r));if((nread=read(fd,buf_r,100))==-1){if(errno==EAGAIN)printf("no data yet\n");}printf("read %s from FIFO\n",buf_r);sleep(1);}   //后面三句话是不会被运行到的，但不会影响程序运行的效果当程序在上面的死循环中执行时收到信号后会马上结束运行而没有执行后面的三句话。这些会在后面的信号处理中讲到，现在不理解没有关系，这个问题留给大家学习了信号处理之后来解决。close(fd); //关闭管道pause(); /*暂停，等待信号*/unlink(FIFO);//删除文件}

（3）信号通信
信号(signal)机制是Unix系统中最为古老的进程间通信机制，很多条件可以产生一个信号：
1、当用户按某些按键时，产生信号。
2、硬件异常产生信号：除数为0、无效的存储访问等等。这些情况通常由硬件检测到，将其通知内核，然后内核产生适当的信号通知进程，例如，内核对正访问一个无效存储区的进程产生一个SIGSEGV信号。

3、进程用kill函数将信号发送给另一个进程。
4、用户可用kill命令将信号发送给其他进程。

信号类型
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGIOT 7) SIGBUS 8) SIGFPE
9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR213) SIGPIPE 14) SIGALRM 15) SIGTERM
17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN 22) SIGTTOU
23) SIGURG 24) SIGXCPU 25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH
29) SIGIO 30) SIGPWR

下面是几种常见的信号：

SIGHUP：从终端上发出的结束信号
SIGINT：来自键盘的中断信号（Ctrl-C）
SIGKILL：该信号结束接收信号的进程
SIGTERM：kill 命令发出的信号
SIGCHLD：标识子进程停止或结束的信号
SIGSTOP：来自键盘（Ctrl-Z）或调试程序的停止执行信号

信号处理

当某信号出现时，将按照下列三种方式中的一种进行处理：
1、忽略此信号
大多数信号都按照这种方式进行处理，但有两种信号却决不能被忽略。它们是：SIGKILL和SIGSTOP。这两种

信号不能被忽略的原因是：它们向超级用户提供了一种终止或停止进程的方法。

2、执行用户希望的动作通知内核在某种信号发生时，调用一个用户函数。在用户函数中，执行用户希望的处理。
3、执行系统默认动作对大多数信号的系统默认动作是终止该进程。

信号发送
发送信号的主要函数有kill和raise。
区别：
Kill既可以向自身发送信号，也可以向其他进程发送信号。与kill函数不同的是，raise函数是向进程自身发送信号。

#include <sys/types.h>#include <signal.h>int kill(pid_t pid, int signo)int raise(int signo)

kill的pid参数有四种不同的情况：
1、pid>0
将信号发送给进程ID为pid的进程。
2、pid == 0
将信号发送给同组的进程。
3、pid < 0
将信号发送给其进程组ID等于pid绝对值的进程。
4、pid ==－1
将信号发送给所有进程。

Alarm
使用alarm函数可以设置一个时间值(闹钟时间)，当所设置的时间到了时，产生SIGALRM信号。如果不捕捉此信号，则默认动作是终止该进程。

#include <unistd.h>unsigned int alarm(unsigned int seconds)

Seconds：经过了指定的seconds秒后会产生信号SIGALRM。
每个进程只能有一个闹钟时间。如果在调用alarm时，以前已为该进程设置过闹钟时间，而且它还没有超时，以前登记的闹钟时间则被新值代换。
如果有以前登记的尚未超过的闹钟时间，而这次seconds值是0，则表示取消以前的闹钟。

pause

pause函数使调用进程挂起直至捕捉到一个信号。

#include <unistd.h>int pause(void)

只有执行了一个信号处理函数后，挂起才结束。

信号的处理
当系统捕捉到某个信号时，可以忽略该信号或是使用指定的处理函数来处理该信号，或者使用系统默认的方式。
信号处理的主要方法有两种，一种是使用简单的signal函数，另一种是使用信号集函数组。

signal

#include <signal.h>void (*signal (int signo, void (*func)(int)))(int)

如何理解？

typedef void (*sighandler_t)(int)sighandler_t signal(int signum, sighandler_t handler))

Func可能的值是：
1、SIG_IGN：忽略此信号
2、SIG_DFL: 按系统默认方式处理
3、信号处理函数名：使用该函数处理

实例分析：mysignal.c

#include <signal.h>#include <stdio.h>#include <stdlib.h>void my_func(int sign_no){if(sign_no==SIGINT)printf("I have get SIGINT\n");else if(sign_no==SIGQUIT)printf("I have get SIGQUIT\n");}int main(){printf("Waiting for signal SIGINT or SIGQUIT\n");/*注册信号处理函数*/signal(SIGINT,my_func);signal(SIGQUIT,my_func);pause();exit(0);}

（4）共享内存
共享内存是被多个进程共享的一部分物理内存。共享内存是进程间共享数据的一种最快的方法，一个进程向共享内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容。

共享内存实现分为两个步骤:
一、创建共享内存，使用shmget函数。
二、映射共享内存，将这段创建的共享内存映射到具体的进程空间去，使用shmat函数。

创建

int shmget ( key_t key, int size, int shmflg )

key标识共享内存的键值: 0/IPC_PRIVATE。当key的取值为IPC_PRIVATE，则函数shmget()将创建一块新的共享内存；如果key的取值为0，而参数shmflg中又设置IPC_PRIVATE这个标志，则同样会创建一块新的共享内存。
返回值：如果成功，返回共享内存标识符；如果失败，返回-1。
映射

int shmat ( int shmid, char *shmaddr, int flag)

参数：

shmid：shmget函数返回的共享存储标识符
flag：决定以什么方式来确定映射的地址（通常为0）

返回值：
如果成功，则返回共享内存映射到进程中的地址；如果失败，则返回- 1。

当一个进程不再需要共享内存时，需要把它从进程地址空间中脱离。

int shmdt ( char *shmaddr )

实例分析：shmem.c（演示）
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define PERM S_IRUSR|S_IWUSR
/*共享内存*/
int main(int argc,char **argv)
{
int shmid;
char *p_addr,*c_addr;
if(argc!=2)
{
fprintf(stderr,"Usage:%s\n\a",argv[0]);
exit(1);
}
/*创建共享内存*/
if((shmid=shmget(IPC_PRIVATE,1024,PERM))==-1)
{
fprintf(stderr,"Create share Memory Error:%s\n\a",
strerror(errno));
exit(1);
}
/*创建子进程*/
if(fork())//父进程写
{
p_addr=shmat(shmid,0,0);
memset(p_addr,'\0',1024);
strncpy(p_addr,argv[1],1024);
wait(NULL);//释放资源，不关心终止状态
exit(0);
}
else//子进程读
{
sleep(1);//暂停1秒
c_addr=shmat(shmid,0,0);
printf("Client get %s\n",c_addr);
exit(0);
}

}

进程间通信程序设计-2

1、消息队列

unix早期通信机制之一的信号能够传送的信息量有限，管道则只能传送无格式的字节流，这无疑会给应用程序开发带来不便。消息队列（也叫做报文队列）则克服了这些缺点。

消息队列就是一个消息的链表。可以把消息看作一个记录，具有特定的格式。进程可以向中按照一定的规则添加新消
息；另一些进程则可以从消息队列中读走消息。

目前主要有两种类型的消息队列：POSIX消息队列以及系统V消息队列，系统V消息队列目前被大量使用。

持续性
系统V消息队列是随内核持续的，只有在内核重起或者人工删除时，该消息队列才会被删除。

键值
消息队列的内核持续性要求每个消息队列都在系统范围内对应唯一的键值，所以，要获得一个消息队列的描述字，必须提供该消息队列的键值。

（1）键值

#include <sys/types.h>#include <sys/ipc.h>key_t ftok (char*pathname, char proj)

功能：返回文件名对应的键值。
pathname:文件名
proj:项目名（不为0即可）

（2）打开/创建

#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>int msgget(key_t key, int msgflg)

key：键值，由ftok获得。
msgflg：标志位。
返回值：与健值key相对应的消息队列描述字。

IPC_CREAT：创建新的消息队列
IPC_EXCL：与IPC_CREAT一同使用，表示如果要创建的消息队列已经存在，则返回错误。
IPC_NOWAIT：读写消息队列要求无法得到满足时，不阻塞。

创建
在以下两种情况下，将创建一个新的消息队列：

如果没有与健值key相对应的消息队列，并且msgflg中包含了IPC_CREAT标志位。
key参数为IPC_PRIVATE。

int open_queue(key_t keyval){int qid;if((qid=msgget(keyval,IPC_CREAT))==-1){return(-1);}return(qid);}

（3）发送消息

#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>int msgsnd(int msqid,struct msgbuf*msgp,int msgsz,int msgflg)

功能：向消息队列中发送一条消息。

msqid：已打开的消息队列id
msgp：存放消息的结构
msgsz：消息数据长度
msgflg：发送标志，有意义的msgflg标志为IPC_NOWAIT，指明在消息队列没有足够空间容纳要发送的消息时，msgsnd是否等待。

消息格式

struct msgbuf{long mtype; /* 消息类型> 0 */ char mtext[1];   /* 消息数据的首地址*/};

（4）接收消息
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgrcv(int msqid, struct msgbuf *msgp, intmsgsz, longmsgtyp, intmsgflg)
功能：从msqid代表的消息队列中读取一个msgtyp类型的消息，并把消息存储在msgp指向的msgbuf结构中。在成功地读取了一条消息以后，队列中的这条消息将被删除。

int read_message(int qid,long type,struct mymsgbuf*qbuf){int result,length;length=sizeof(struct mymsgbuf)-sizeof(long);if((result=msgrcv(qid,qbuf,length,type,0))==-1)return(-1);return(result);}

实例分析:msg.c（演示）

#include <sys/types.h>#include <sys/msg.h>#include <unistd.h>struct msg_buf{int mtype;char data[255];};int main(){key_t key;int msgid;int ret;struct msg_buf msgbuf;key=ftok("/tmp/2",'a');printf("key=[%x]\n",key);msgid=msgget(key,IPC_CREAT|0666);//通过文件对应if(msgid==-1){printf("create error\n");return -1;}msgbuf.mtype=getpid();strcpy(msgbuf.data,"test haha");ret=msgsnd(msgid,&msgbuf,sizeof(msgbuf.data),IPC_NOWAIT);if(ret==-1){printf("send message err\n");return -1;}memset(&msgbuf,0,sizeof(msgbuf));ret=msgrcv(msgid,&msgbuf,sizeof(msgbuf.data),getpid(),IPC_NOWAIT);if(ret==-1){printf("recv message err\n");return -1;}printf("recv msg=[%s]\n",msgbuf.data);}

2、信号量
信号量(又名：信号灯)与其他进程间通信方式不大相同，主要用途是保护临界资源。进程可以根据它判定是否能够访问某些共享资源。除了用于访问控制外，还可用于进程同步。

分类：

二值信号灯：信号灯的值只能取0或1，类似于互斥锁。但两者有不同：信号灯强调共享资源，只要共享资源可用，其他进程同样可以修改信号灯的值；互斥锁更强调进程，占用资源的进程使用完资源后，必须由进程本身来解锁。
计数信号灯：信号灯的值可以取任意非负值。

（1）创建/打开

#include <sys/types.h>#include <sys/ipc.h>#include <sys/sem.h>int semget(key_t key, int nsems, int semflg)

key：键值，由ftok获得
nsems：指定打开或者新创建的信号灯集中将包含信号灯的数目
semflg：标识，同消息队列

（2）操作

int semop(int semid, struct sembuf *sops, unsigned nsops)

功能：对信号量进行控制。

semid：信号量集的ID
sops：是一个操作数组，表明要进行什么操作
nsops：sops所指向的数组的元素个数。

struct sembuf

{unsigned short sem_num; /* semaphoreindex in array */short sem_op;        /* semaphore operation */short sem_flg;                       /* operation flags */};

sem_num：要操作的信号量在信号量集中的编号，第一个信号的编号是0。
sem_op：如果其值为正数，该值会加到现有的信号量值中，通常用于释放信号量；如果sem_op的值为负数，而其绝对值又大于信号的现值，操作将会阻塞，直到信号值大于或等于sem_op的绝对值，通常用于获取信号量；如果sem_op的值为0，则操作将暂时阻塞，直到信号的值变为0。
Sem_flg：信号操作标志，可能的选择有两种： IPC_NOWAIT:对信号的操作不能满足时，semop()不会阻塞，并立即返回，同时设定错误信息；IPC_UNDO:程序结束时(不论正常或不正常)释放信号量，这样做的目的在于避免程序在异常情况下结束时未将锁定的资源解锁，造成该资源永远锁定。

0 0