Linux 传统的进程间通信有很多,如各类管道、消息队列、内存共享、信号量等等。但它们都无法介于内核态与用户态使用,原因如表
通信方法 | 无法介于内核态与用户态的原因 |
管道(不包括命名管道) | 局限于父子进程间的通信。 |
消息队列 | 在硬、软中断中无法无阻塞地接收数据。 |
信号量 | 无法介于内核态和用户态使用。 |
内存共享 | 需要信号量辅助,而信号量又无法使用。 |
套接字 | 在硬、软中断中无法无阻塞地接收数据。 |
一.进程
1.进程表
ps显示正在运行的进程
# ps -ef
TIME 进程目前占用的cpu时间,CMD显示启动进程所使用的命令
#ps ax
STAT表明进程的状态
S 睡眠,s进程是会话期首进程;R 运行;D 等待;T 停止;Z 僵尸;N 低优先级任务,nice;W 分页;
+进程属于前台进程组;l 进程是多线程;<高优先级任务
#ps -l
表现良好的程序为nice程序,系统根据进程的nice值决定他的优先级
-f是长格式
2.父子进程id
pid当前进程的;
uid当前进程的实际用户
eid当前进程的有效用户
#include <stdio.h>
#include <unistd.h>
main()
{
}
运行结果:
3.设置进程组id以及进程sleep
setpgid使当前进程为新进程组的组长
#include <stdio.h>
#include <unistd.h>
main()
{
}
说明:setpgid(0,0)等价于setpgrp(0,0)
setpgid(0,0)第1个参数用于指定要修改的进程id。如果为0,则指当前进程。第2个参数用于指定新的进程组id。如果为0,则指当前进程。
先运行程序
#./example13_2
再查看进程
#ps alef
#ps -ao pid,pgrp,cmd|grep 13_2
或者
#ps -ao pid,pgrp,cmd
4.子进程
fork为0说明是父进程
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
main()
{
}
输出
fork...
AA
注意:
警告: 隐式声明与内建函数 ‘exit’ 不兼容
警告: 隐式声明与内建函数 ‘sprintf’ 不兼容
警告: 隐式声明与内建函数 ‘printf’ 不兼容
加入这两个头文件就可以了!
#include <stdio.h>
#include <stdlib.h>
#ps -ao pid,pgrp,cmd
3165就是子进程
#ps alef
5.进程会话
setsid的调用进程应该不是某个进程组的组长进程;
setsid调用成功后生成新会话,新会话id是调用进程的进程id;
新会话只包含一个进程组一个进程即调用进程,没有控制终端。
setid主要是实现进程的后台运行
#include <stdio.h>
#include <unistd.h>
#include <sys/param.h>
#include <stdlib.h>
main()
{
}
修改后的程序
#include <stdio.h>
#include <unistd.h>
#include <sys/param.h>
#include <stdlib.h>
main()
{
wait(0);
}
父进程必须调用wait等待子进程推出,如果没有子进程退出exit,则wait进入阻塞!
6.进程的控制终端
#tty
在secureCRT中观看其他的会输出
/dev/pts/1等依次类推
#ps -ax
查看进程的控制终端
有列tty的就是控制终端,有值表明进程有控制终端,无则表明是后台进程。
7.进程的状态
可运行;
等待;
暂停;
僵尸;
进程在终止前向父进程发送SIGCLD信号,父进程调用wait等待子进程的退出!
如果,父进程没有调用wait而子进程已经退出,那么父进程成为僵尸进程;
如果,父进程没有等子进程退出自己已经先退出,那么子进程成为孤儿进程;
通过top命令看到
8.进程的优先级
优先级数值越低,则优先级越高!
优先级由优先级别(PR)+进程的谦让值(NI)
PR值是由父进程继承而来,是不可修改的。
Linux提供nice系统调用修改自身的NI值;setpriority系统调用可以修改其他进程以及进程组的NI值。
#include <unistd.h>
#include <errno.h>
#include <sys/resource.h>
#include <stdlib.h>
#include <stdio.h>
main()
{
}
输出:
priority is 3
9.用fork创建进程
调用fork一次返回2次,分别在父进程和子进程中返回,父进程中其返回值是子进程的进程标识符,子进程中其返回值是0。
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
}
(注意保存为UTF-8格式,因为有中文)
输出:
10.vfork和fork之间的区别
vfork用于创建一个新进程,而该新进程的目的是exec一个新进程,vfork和fork一样都创建一个子进程,但是它并不将父进程的地址空间完全复制到子进程中,不会复制页表。因为子进程会立即调用exec,于是也就不会存放该地址空间。不过在子进程中调用exec或exit之前,他在父进程的空间中运行。
为什么会有vfork,因为以前的fork当它创建一个子进程时,将会创建一个新的地址空间,并且拷贝父进程的资源,而往往在子进程中会执行exec调用,这样,前面的拷贝工作就是白费力气了,这种情况下,聪明的人就想出了vfork,它产生的子进程刚开始暂时与父进程共享地址空间(其实就是线程的概念了),因为这时候子进程在父进程的地址空间中运行,所以子进程不能进行写操作,并且在儿子“霸占”着老子的房子时候,要委屈老子一下了,让他在外面歇着(阻塞),一旦儿子执行了exec或者exit后,相当于儿子买了自己的房子了,这时候就相当于分家了。
vfork和fork之间的另一个区别是: vfork保证子进程先运行,在她调用exec或exit之后父进程才可能被调度运行。如果在调用这两个函数之前子进程依赖于父进程的进一步动作,则会导致死锁。
由此可见,这个系统调用是用来启动一个新的应用程序。其次,子进程在vfork()返回后直接运行在父进程的栈空间,并使用父进程的内存和数据。这意味着子进程可能破坏父进程的数据结构或栈,造成失败。
为了避免这些问题,需要确保一旦调用vfork(),子进程就不从当前的栈框架中返回,并且如果子进程改变了父进程的数据结构就不能调用exit函数。子进程还必须避免改变全局数据结构或全局变量中的任何信息,因为这些改变都有可能使父进程不能继续。
通常,如果应用程序不是在fork()之后立即调用exec(),就有必要在fork()被替换成vfork()之前做仔细的检查。
用fork函数创建子进程后,子进程往往要调用一种exec函数以执行另一个程序,当进程调用一种exec函数时,该进程完全由新程序代换,而新程序则从其main函数开始执行,因为调用exec并不创建新进程,所以前后的进程id 并未改变,exec只是用另一个新程序替换了当前进程的正文,数据,堆和栈段。
11.exec
清除父进程的可执行代码影像,用新代码覆盖父进程。
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
main()
{
}
12.system创建进程
system系统调用是为了方便调用外部程序,执行完毕后返回调用进程。
#include <stdio.h>
#include <stdlib.h>
main()
{
}
输出:
13.退出进程
调用exit退出进程
调用wait等待进程退出
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
void handle_sigcld(int signo)
{
}
main()
{
}
输出:
二.信号
信号又称软终端,通知程序发生异步事件,程序执行中随时被各种信号中断,进程可以忽略该信号,也可以中断当前程序转而去处理信号,引起信号原因:
1).程序中执行错误码;
2).其他进程发送来的;
3).用户通过控制终端发送来;
4).子进程结束时向父进程发送SIGCLD;
5).定时器生产的SIGALRM;
1.信号分类
#kill -l
获取信号列表,信号值)
1-31是不可靠信号(可能丢失);32-64是可靠信号(操作系统保证不丢失)
信号列表参考:http://blog.csdn.net/21aspnet/article/details/7494565
信号安装:定义进程收到信号后的处理方法
signal系统调用安装信号
#include <stdio.h>
#include <signal.h>
void HandleSigint(int signo)//信号处理函数
{
}
main()
{
}
输出:
按Ctrl+C
receive signal 2
sigaction系统调用(更多的控制,完全可以替代signal)
#include <stdio.h>
#include <signal.h>
void HandleSigint(int signo,siginfo_t *info,void *none)
{
}
main()
{
}
输出:
按Ctrl+C
receive signal 2,addtional data is 12364176
2.信号处理方式3种:
1.忽略信号-大多可以忽略,只有SIGKILL和SIGSTOP除外;
2.捕捉信号-先安装
3.默认操作
3.信号阻塞
阻塞是指系统内核暂停向进程发送指定信号,由内核对进程接收到的信号缓存,直到解除阻塞为止。
信号3种进入阻塞的情况:
1.信号处理函数执行过程中,该信号将阻塞;
2.通过sigaction信号安装,如果设置了sa_mask阻塞信号集;
3.通过系统调用sigprocmask
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
参数:
how:用于指定信号修改的方式,可能选择有三种
SIG_BLOCK //加入信号到进程屏蔽。
SIG_UNBLOCK //从进程屏蔽里将信号删除。
SIG_SETMASK //将set的值设定为新的进程屏蔽。
set:为指向信号集的指针,在此专指新设的信号集,如果仅想读取现在的屏蔽值,可将其置为NULL。
oldset:也是指向信号集的指针,在此存放原来的信号集。
#include <stdio.h>
#include <signal.h>
void handle_sigint(int signo)
{
}
main()
{
}
输出:如果不输入Ctrl+C则10秒后程序结束;如果期间有Ctrl+C则会10秒结束,之后输出Creceive signal 2
注意:子进程会继承父进程的信号掩码
4.信号集操作
对信号集中所有信号处理
数据类型 sigset_t
清空信号集sigemptyset
信号集填充全部信号sigfillset
信号集增加信号sigaddset
信号集中删除信号sigdelset
判断信号集是否包含某信号的sigismember
5.未决信号
信号产生后到信号被接收进程处理前的过渡状态,未决状态时间很短。
sigprocmask阻塞某种信号,则向进程发送这种信号处于未决状态。
sigpending获取当前进程中处于未决状态的信号
#include <stdio.h>
#include <signal.h>
void handle_sigint(int signo)
{
}
main()
{
}
6.等待信号
阻塞式系统如果没有符合条件的数据将休眠,直到数据到来,例如socket上读取数据。有2种状态可以中断该操作
1.网络上有数据,读操作获取数据后返回
2.当前进程接收信号,读操作被中断返回失败,错误码errno为EINTR
pause系统调用可以让程序暂停执行进入休眠,等待信号到来。
#include <stdio.h>
#include <signal.h>
int nInterrupt;
void handle_sigint(int signo)
{
}
main()
{
}
7.信号发送
两种方式
kill
sigqueue
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
void HandleSigint(int signo,siginfo_t *info,void *none)
{
}
main()
{
}
输出:receive addtional data is 123
8.sigalarm信号
阻塞式系统调用,为避免无限期等待,可以设置定时器信号,alarm调用
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
int timeout;
void Handle_Alarm(int signo)
{
}
main()
{
}
输出:
SIGALRM received.
Pause time out.
9.sigcld信号
父进程捕获子进程的退出信号
子进程发送SIGCLD信号进入僵尸状态;父进程接收到该信号处理,子进程结束
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
void Handle_Sigcld(int signo)
{
}
main()
{
}
输出:
三.管道
单向,一段输入,另一端输出,先进先出FIFO。管道也是文件。管道大小4096字节。
特点:管道满时,写阻塞;空时,读阻塞。
分类:普通管道(仅父子进程间通信)位于内存,命名管道位于文件系统,没有亲缘关系管道只要知道管道名也可以通讯。
1.pipe建立管道
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
int main(int argc, char *argv[])
{
}
说明:每调用一次fork
执行
#./a.out
输出
#www
2.dup
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
int main()
{
int pfds[2];
if ( pipe(pfds) == 0 )
{
}
return 0;
}
说明:相当于执行# ls -l |wc -l
wc参考http://blog.csdn.net/21aspnet/article/details/7515442
linux命令集锦http://blog.csdn.net/21aspnet/article/details/1534099
linux常用命令
3.popen() 函数
用于创建一个管道,其内部实现为调用 fork 产生一个子进程,执行一个 shell 以运行命令来开启一个进程,这个进程必须由 pclose() 函数关闭。
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
int main( void )
{
}
输出:
4.命名管道
mknod
mknod 管道名称 p
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int mknod(const char *pathname, mode_t mode, dev_t dev);
mkfifo
mkfifo -m 权限
#include<sys/types.h>
#include<sys/stat.h>
int mkfifo(const char * pathname,mode_t mode);
mknod和mkfifo的区别
mknod系统调用会产生由参数path锁指定的文件,生成文件类型和访问权限由参数mode决定。
在很多unix的版本中有一个C库函数mkfifo,与mknod不同的是多数情况下mkfifo不要求用户有超级用户的权限
利用命令创建命名管道p1.
#mkfifo -m 0644 p1
#mknod p2 p
#ll
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
main()
{
}
5.管道读写
通过open打开,默认是阻塞方式打开,如果open指定O_NONBLOCK则以非阻塞打开。
O_NONBLOCK和O_NDELAY所产生的结果都是使I/O变成非搁置模式(non-blocking),在读取不到数据或是写入缓冲区已满会马上return,而不会搁置程序动作,直到有数据或写入完成。
它们的差别在于设立O_NDELAY会使I/O函式马上回传0,但是又衍生出一个问题,因为读取到档案结尾时所回传的也是0,这样无法得知是哪中情况;因此,O_NONBLOCK就产生出来,它在读取不到数据时会回传-1,并且设置errno为EAGAIN。
不过需要注意的是,在GNU C中O_NDELAY只是为了与BSD的程序兼容,实际上是使用O_NONBLOCK作为宏定义,而且O_NONBLOCK除了在ioctl中使用,还可以在open时设定。
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
main()
{
}
四.IPC对象
查看ipc对象信息
#ipcs
查看全部ipc对象信息
#ipcs -a
查看消息队列信息
#ipcs -q
查看共享内存信息
#ipcs -m
查看信号量信息
#ipcs -s
删除IPC对象的ipcrm
ipcrm -[smq] ID 或者ipcrm -[SMQ] Key
-q
-m -M删除共享内存信息
-s -S删除信号量信息
ftok函数
产生一个唯一的关键字值
ftok原型如下:
key_t ftok( char * fname, int id )
fname就是你指定的文件名(该文件必须是存在而且可以访问的),id是子序号,虽然为int,但是只有8个比特被使用(0-255)。
当成功执行的时候,一个key_t值将会被返回,否则 -1 被返回。
查询文件索引节点号的方法是: ls -i
以下为测试程序:
ftok.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#define IPCKEY 0x11
int main( void )
{
}
#ls -i ftok.c
#./a.out
五.消息队列
消息队列是先进先出FIFO原则
1.消息结构模板
strut msgbuf
{
long int
char mtext[1];//消息内容
}
2.msgget创建消息
#include <sys/msg.h>
int msgget(key_t key, int flag);
此函数返回key指定消息的标识符
key 一般有ftok函数产生 ,该函数为key_t ftok(const char *pathname, int proj_id);
该函数把从pathname导出的信息与id低8位组合成一个整数IPC键, 调用时pathname必须存在,若不存在ftok调用失败,返回-1,成功返回该整数IPC键值
flag 为该消息队列的读写权限组合,可以与IPC_CREAT 或IPC_EXCL相与,其中创建对列时都要使用IPC_CREAT,其中IPC_CREAT|IPC_EXCL含义是若已有该队列则返回错误
此函数成功时,返回非负队列标识符;失败时返回-1
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
main()
{
//带参数IPC_CREAT和IPC_EXCL,如果队列不存在则创建队列,已存在则返回EEXIST
}
3.msgsnd消息发送
int msgsnd(int msqid, const void *ptr, size_t length, int flag);
此函数发送消息到指定的消息对列
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
typedef struct
{
}MSG;
main()
{
}
队列中已经有一条消息,长度6字节
4.msgrcv消息发送
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
typedef struct
{
}MSG;
main()
{
}
输出:
msgrcv return length=[6] text=[123456]
5.msgctl控制消息
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
消息队列控制函数
其中msqid为消息队列描述符
cmd有以下三种:
IPC_RMID:删除msgid指定的消息队列,当前在该队列上的任何消息都被丢弃,对于该命令,buf参数可忽略
IPC_SET:设置消息队列msgid_ds结构体的四个成员:msg_perm.uid,msg_perm_gid,msg_perm.mode和msg_qbytes。它们的值来自由buf指向的结构体中的相应成员。
IPC_STAT:给调用者通过buf返回指定消息队列当前对应msgid_ds结构体
函数执行成功返回0,失败返回-1
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
typedef struct
{
}MSG;
main()
{
}
说明: (~0222)取反后做与实际上就是去除其他用户的写权限,在C语言中,八进制常用用前缀表示
六.共享内存
共享内存是分配一块能被其他进程访问的内存,实现是通过将内存去映射到共享它的进程的地址空间,使这些进程间的数据传送不再涉及内核,即,进程间通信不需要通过进入内核的系统调用来实现;
共享内存与其他的进程间通信最大的优点是:数据的复制只有两次,一次是从输入文件到共享内存区,一次从共享内存区到输出文件
而其他的则是需要复制4次:服务器将输入文件读入自己的进程空间,再从自己的进程空间写入管道/消息队列等;客户进程从管道/消息队列中读出数据到自己的进程空间,最后输出到客户指定的文件中;
要使用共享内存,应该有如下步骤:
1.开辟一块共享内存
2.允许本进程使用共某块共享内存
3.写入/读出
4.禁止本进程使用这块共享内存
5.删除这块共享内存
1.shmget创建共享内存
#include <sys/shm.h>
int
shmget()是用来开辟/指向一块共享内存的函数。参数定义如下:
key_t shmkey 是这块共享内存的标识符。如果是父子关系的进程间通信的话,这个标识符用IPC_PRIVATE来代替
int shmsiz 是这块内存的大小.
int flag 是这块内存的模式(mode)以及权限标识
模式可取如下值:
然后将“模式” 和“权限标识”进行“或”运算,做为第三个参数
如:
这个函数成功时返回共享内存的ID,失败时返回-1。
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
main()
{
}
2.shmat映射共享内存
shmat()是用来允许本进程访问一块共享内存的函数。
void *shmat(int _shmid,_const void *_shmaddr,int _shmflg);
int shmid是那块共享内存的ID。
char *shmaddr是共享内存的起始地址
int shmflag是本进程对该内存的操作模式。如果是SHM_RDONLY的话,就是只读模式。其它的是读写模式
成功时,这个函数返回共享内存的起始地址。失败时返回-1。
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>
typedef struct
{
} ShmStru;
main()
{
}
3.shmdt删除共享内存映射
shmdt()解除共享内存与进程地址空间的映射
int shmdt(_const void * _shmaddr);
参数char *shmaddr是那块共享内存的起始地址
成功时返回0。失败时返回-1。
4.shmctl控制共享内存映射
shmctl()函数如下:
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int
int shmid是共享内存的ID。
int cmd是控制命令,可取值如下:
struct shmid_ds *buf是一个结构体指针。IPC_STAT的时候,取得的状态放在这个结构体中。如果要改变共享内存的状态,用这个结构体指定
返回值:成功:0
简单解释一下ipcs命令和ipcrm命令。
取得ipc信息:
ipcs [-m|-q|-s]
-m
-q
-s
%ipcs -m
删除ipc
ipcrm -m|-q|-s shm_id
%ipcrm -m 105
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>
typedef struct
{
} ShmStru;
main()
{
}
说明:
七.信号量
信号量是一种用于提供不同进程间或一个进程间的不同线程间线程同步手段的原语,systemV信号量在内核中维护
二值信号量 : 其值只有0、1 两种选择,0表示资源被锁,1表示资源可用;
计数信号量:其值在0 和某个限定值之间,不限定资源数只在0 1 之间;
计数信号量集 ;多个信号量的集合组成信号量集
1.信号量集结构semid_ds
内核维护的信号量集结构信息如下
定义在头文件<sys/sem.h>
其中ipc_perm 结构是内核给每个进程间通信对象维护的一个信息结构,其成员包含所有者用户id,所有者组id、创建者及其组id,以及访问模式等;
semid_ds结构体中的sem结构是内核用于维护某个给定信号量的一组值的内部结构,其结构定义:
semid_ds结构体中的sem_nsems成员代表该信号量标示符的信号量个数
求信号量极值
#
说明:输出格式是
每个信号量集最大信号量数目
2.semget创建信号量
int semget(key_t key, int nsems, int semflg);
该函数执行成功返回信号量标示符,失败返回-1
参数key是通过调用ftok函数得到的键值,nsems代表创建信号量的个数,如果只是访问而不创建则可以指定该参数为0,我们一旦创建了该信号量,就不能更改其信号量个数,只要你不删除该信号量,你就是重新调用该函数创建该键值的信号量,该函数只是返回以前创建的值,不会重新创建;
semflg 指定该信号量的读写权限,当创建信号量时不许加IPC_CREAT ,若指定IPC_CREAT |IPC_EXCL则创建是存在该信号量,创建失败;
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/sem.h>
main()
{
}
输出:
3.semop改变信号量值
信号量操作是PV 操作,“互斥”与“同步”
该函数执行成功返回0,失败返回-1;
第一个参数semid 为信号量标示符;nops为第二个参数的操作数组的个数,第二个参数sops为一个结构体数组指针,结构体定义在sys/sem.h中,结构体如下
sem_num 操作信号的下标,其值可以为0 到nops
sem_flg为该信号操作的标志:其值可以为0、IPC_NOWAIT 、 SEM_UNDO
0
SEM_UNDO当操作的进程推出后,该进程对sem进行的操作将被取消;
sem_op取值 >0 则信号量加上它的值,等价于进程释放信号量控制的资源
sem_op取值 =0若没有设置IPC_NOWAIT, 那么调用进程 将进入睡眠状态,直到信号量的值为0,否则进程直接返回
sem_op取值 <0则信号量加上它的值,等价于进程申请信号量控制的资源,若进程设置IPC_NOWAIT则进程再没有可用资源情况下,进程 阻 塞,否则直接返回
3.semctl控制信号量
该函数执行成功返回非负值,失败返回-1
参数semid为信号集的标识符;
参数 semnum标识一个特定信号,该参数仅用于 SETVAL、GETVAL、GETPID命令
cmd控制类型;
...说明函数参数是可选的,通过该共用体变量semun选择操作参数,各字段如下:
struct seminfo {
int semmap;
int semmni;
int semmns;
int semmnu;
int semmsl;
int semopm;
int semume;
int semusz;
int semvmx;
int semaem;
};
semctl的cmd参数
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <string.h>
typedef union semun//semctl需要的
{
} SEMCTL_UNION;
main()
{
}
输出:
==============================================================
扩展阅读参考:
系统调用跟我学(1)系统调用跟我学(2)系统调用跟我学(3)系统调用跟我学(4)