http://www.tuicool.com/articles/3QNRnaz
linux之多线程fork:进程通信
++++++++++++++++++信号机制+++++++++++++ ++++++
接收信号
int signal(int sig,__sighandler_t handler); int func(int sig);
sig 指明了所要处理的信号类型，handler是SIG_IGN，SIG_DFL或者返回值为整数的函数地址。
当执行了signal函数后,进程只要接收到类型为sig 的信号,就立即执行 func()函数，不管其正在执行程序的哪一部分。当func()函数执行结束后,程序返回到进程被中断的那一点继续执行。
忽略中止信号：
#include <signal.h>
int main()
{
signal(SIGINT,SIG_IGN); /*告诉进程将 SIGINT 信号忽略*/
cout<<"start"<<endl;
sleep(3); /*在此期间，无法中止程序运行*/
cout<<"end"<<endl;
return 0;
}void fun(int sig)
{
cout<<endl;
cout<<"ctrl-c"<<endl;
}
int main()
{
signal(SIGINT,fun); /*告诉进程将 SIGINT 信号忽略*/
cout<<"start"<<endl;
sleep(3); /*中止程序运行时，调用fun函数*/
cout<<"end"<<endl;
return 0;
}输出：
start
^C
ctrl-c
end发送信号
int kill(pid_t pid,int sig);参数 pid 指定了信号发送的对象进程。
如果 pid 为零,则信号被发送到当前进程所在的进程组的所有进程;
如果 pid 为-1,则信号按进程标识符从高到低的顺序发送给全部的进程;
如果 pid 小于-1,则信号被发送给标识符为 pid 绝对值的进程组里的所有进程。
参数 sig 指定发送的信号类型。它可以是任何有效的信号。
普通用户的进程只能向具有与其相同的用户标识符的进程发送信号。
int n=0;
void fun(int sig)
{
cout<<n++<<endl;
}
int main()
{
signal(SIGUSR1,fun);受到信号执行fun函数
pid_t pid;
pid=fork();
if(pid==0)
{
pid_t ppid=getppid();
for(int i=0;i<5;i++){kill(ppid,SIGUSR1);sleep(1);}//发送信号
}
else if(pid>0)
{
wait(NULL);
}
else
{
perror("fork Error!");
exit(1);
}
return 0;
}输出： 0 1 2 3 4
ALARM信号
当进程在alarm(）的规定时间内没有完成的话，就会发送一个ALARM信号void fun(int sig) { cout<<"alarm 5"<<endl; } int main() { signal(SIGALRM,fun); pid_t pid; pid=fork(); if(pid==0) { pid_t ppid=getppid(); alarm(5);//设置定时器，在5秒时将发送超时信号,并终止子进程执行。 sleep(8); } else if(pid>0) { wait(NULL); } else { perror("fork Error!"); exit(1); } return 0; }
pause函数
pause等待进程捕捉并处理信号。
void fun(int sig){} int main() { signal(SIGALRM,fun); alarm(1); pause();//处于等待状态。 return 0; }
++++++++++++++++++管道++++++++++++++++++
实现父子进程间的通信
Pipe函数
Pipe(int fd[2])
fd用于存放 pipe()函数新建立的管道句柄
fd[0]是从管道中读出数据的句柄
fd[1]是向管道写入数据的句柄。即fd[1]的写入由 fd[0]读出。
int main() { int fd[2]; char buf[100]={'\0'}; pid_t pid; pipe(fd);//建立管道 pid=fork();//建立子进程 if(pid>0) { close(fd[1]);//关闭不需要的句柄 read(fd[0],buf,100); cout<<buf<<endl; } else if(pid==0) { close(fd[0]);//关闭不需要的句柄 strcpy(buf,"hello"); write(fd[1],buf,100); } else {exit(1);} return 0; }
dup函数
int dup(int oldfd);
将管道句柄重定向到标准输入/输出上最小的未使用的句柄.
在使用dup函数前最好将原句柄关闭.
int main() { int fd[2]; char buf[100]; char tmp[100]; pid_t pid; pipe(fd); pid=fork(); if(pid>0) { close(fd[1]); close(0);//关闭标准输入,0句柄是最小未使用句柄. dup(fd[0]); cin>>buf; cout<<buf<<endl; } else if(pid==0) { close(fd[0]); close(1);//关闭标准输出,1句柄是最小未使用句柄. dup(fd[1]); strcpy(tmp,"hello"); cout<<tmp<<endl; } else {exit(1);} return 0; }
dup2函数
dup2函数相当于
close(0);
dup(fd[0]);
这两条语句.
int main()
{
int fd[2];
char buf[100]={'\0'};
char tmp[100]={'\0'};
pid_t pid;
pipe(fd);
pid=fork();
if(pid>0)
{
close(fd[1]);
dup2(fd[0],0);
cin>>buf;//从管道读入
cout<<buf<<endl;
}
else if(pid==0)
{
close(fd[0]);
dup2(fd[1],1);
strcpy(tmp,"hello");
cout<<tmp<<endl;//读出到管道
}
else {exit(1);}
return 0;
}popen()/pclose()函数
FILE *popen(char *command,char *type);
int pclose(FILE *stream);
popen()函数首先调用 pipe()函数建立一个管道,然后用 fork()函数建立一个子进程,运行一个 shell 环境,然后在这个 shell 环境中运行"command"参数指定的程序。数据在管道中流向由"type"参数控制。这个参数可以是"r"或者"w",分别代表读和写。
int main()
{
FILE *pipe_fp;
if((pipe_fp = popen("ps -ef","r"))== NULL)//设置一个管道读.
{
perror("popen");
exit(1);
}
char buf[100]={'\0'};
fread(buf,1,99,pipe_fp);//从管道中读.
cout<<buf<<endl;
/* 关闭管道 */
pclose(pipe_fp);
return(0);
}++++++++++++++++有名管道++++++++++++++++
解决管道不能提供非父/子关系进程间通信的缺陷.
在读取数据时,若管道中没有数据,有名管道会自动阻塞直到读取到数据为止.
int mknod(char *pathname,mode_t mode,dev_t dev); pathname:要创建的文件的名称; mode:文件类型; dev:该文件对应的设备文件的设备号。只有当文件类型为 S_IFCHR 或 S_IFBLK 的时候该文件才有设备号，创建普通文件时传入0即可。如下:S_IFIFO表示要创建一个FIFO文件，0666表示该文件的权限是所有人可读可写，0表示该文件不是一个设备文件。
管道读
#include <sys/stat.h> #include <unistd.h> int main() { char buf[100]={'\0'}; mknod("./tmpss",S_IFIFO|0666,0); FILE *fp=fopen("./tmpss","r"); fgets(buf,100,fp);//阻塞等待读取数据 fclose(fp); cout<<buf<<endl; return(0); }管道写.
int main() { FILE *fp = fopen("./tmpss","w") fputs("hello",fp); fclose(fp); return(0); }
++++++++++++++++++文件锁++++++++++++++++++
文件和记录锁定可分为咨询式锁定和强制锁定两种。
System V
int lockf(int fd,int function,long size); function可以是以下取值: F_ULOCK:为一个先前锁定的区域解锁 F_LOCK:锁定一个区域,如果指定文件的对应区域已被其它进程锁定,那么 lockf 的调用进程将被阻塞直到该区域解锁。 F_TLOCK:测试并锁定一个区域,如果被测试的区域上了锁,lockf便会立即返回-1,出错返回码 errno 将为 EAGAIN. F_TEST:测试一个区域是否已经上锁。 参数 size 指明了从文件当前位置开始的一段连续锁定区域的长度,当 size 为 0 时,锁定记录将由当前位置一直扩展到文件尾。
#include <unistd.h> int main() { int fd; char buf[2]={'\0'}; if((fd=open("data",O_RDWR))<=0) { perror("Can't open"); exit(1); } if(lockf(fd,F_LOCK,0)!=-1)//阻塞直到成功加锁 { int i=0; while(i++<3) { lseek(fd,0,0); read(fd,buf,1); buf[0]+=1; cout<<buf<<endl; lseek(fd,0,0); write(fd,buf,1); } ockf(fd,F_ULOCK,0); } close(fd); return(0); }连续执行两次输出
start
2
3
4
start
5
6
7BSD
int flock(int fd,int operation);
调用 flock 有两个参数:
fd:一个已打开文件的文件描述符;
operation可以是以下取值:
LOCK_SH:共享锁
LOCK_EX:互斥锁
LOCK_UN:解锁
LOCK_NB:当文件已被锁定时不阻塞#include <sys/file.h> int main() { int fd; char buf[2]={'\0'}; if((fd=open("data",O_RDWR))<=0) { perror("Can't open"); exit(1); } if(flock(fd,LOCK_EX)!=-1)//设置阻塞性互斥锁 { int i=0; while(i++<3) { lseek(fd,0,0); read(fd,buf,1); buf[0]+=1; cout<<buf<<endl; lseek(fd,0,0); write(fd,buf,1); } flock(fd,F_ULOCK); } close(fd); return(0); }连续执行两次输出:
start
2
3
4
start
5
6
7++++++++++++++++消息队列++++++++++++++++
key_t ftok(char *pathname,char proj);获取一个消息队列的标识符。
pathname和proj可以随意指定,不同的<pathname,proj>产生不同的标识符.收发消息双方应使用相同的<pathname,proj>.
如果是父子关系的进程间通信的话，这个标识符用IPC_PRIVATE来代替。如果两个进程没有任何关系，就用ftok()。
int msgget(key_t key,int msgflg)创建新的消息队列或获取已有的消息队列。
key:消息队列对象的关键字(key).
msgflg可以是以下取值:
IPC_CREAT:如果消息队列对象不存在,则创建,否则进行打开操作;
IPC_EXCL:和IPC_CREAT一起使用(用”|”连接),保证所得的消息队列对象是新创建的而不是打开已有的对象。
int msgsnd(int msqid,struct msgbuf *msgp,int msgsz,int msgflg)msqid 是消息队列对象的标识符.
msgp 指向要发送的消息所在的内存.
msgsz 是要发送信息的长度(字节数),可以用公式计算:msgsz = sizeof(struct mymsgbuf)- sizeof(long);
msgflg可以是以下取值:
0,忽略标志位;
IPC_NOWAIT,如果消息队列已满,消息将不被写入队列,立即返回。如果不指定这个参数,线程将被阻塞直到消息被可以被写入。
int msgctl(int msgqid, int cmd, struct msqid_ds *buf)msgqid:消息队列对象的标识符。
cmd可以是以下取值:
IPC_STAT:取出系统保存的消息队列的 msqid_ds 数据,并将其存入参数 buf 指向的 msqid_ds 结构中。
IPC_SET:设定消息队列的 msqid_ds 数据中的 msg_perm 成员。设定的值由 buf 指向的 msqid_ds结构给出。
IPC_EMID:将队列从系统内核中删除。
发送消息:
#include <sys/msg.h>
struct mymsgbuf {
long msgtype;
char msgtext[100]={'\0'};
};
int main()
{
mymsgbuf buf;
buf.msgtype=1;
strcpy(buf.msgtext,"hello");
key_t key = ftok(".",'a');
int msgqueue_id = msgget(key, IPC_CREAT|IPC_EXCL|0660);
msgsnd(msgqueue_id,(mymsgbuf*)&buf,sizeof(buf.msgtext),0);
return(0);
}struct mymsgbuf {
long msgtype;
char msgtext[100]={'\0'};
};
int main()
{
mymsgbuf buf;
key_t key = ftok(".",'a');
int msgqueue_id = msgget(key, IPC_CREAT|0660);
msgrcv(msgqueue_id,(mymsgbuf*)&buf,100,1,0);
msgctl(msgqueue_id, IPC_RMID, 0);
cout<<buf.msgtext<<endl;
return(0);
}hello
++++++++++++++++++信号量++++++++++++++++++
struct sembuf {
unsigned short sem_num;
short sem_op;
short sem_flg;
};sem_num 成员为接受操作的信号量在信号量数组中的序号(数组下标)。
sem_op 成员定义了进行的操作(可以是正、负和零)。
sem_flg 是控制操作行为的标志。
如果 sem_op 是负值,就从指定的信号量中减去相应的值。
如果 sem_op 是正值,就在指定的信号量中加上相应的值。
如果 sem_op 是零,那么调用 semop()函数的进程就会被阻塞直到对应的信号量值为零。
int semget(key_t key, int nsems, int semflg);建立新的信号量对象或者获取已有对象的标识符。
nsems:指定新生成的信号量对象中信号量的数目。
key:消息队列对象的关键字(key).
semflg可以是以下取值:
IPC_CREAT:如果消息队列对象不存在,则创建,否则进行打开操作;
IPC_EXCL:和IPC_CREAT一起使用(用”|”连接),保证所得的消息队列对象是新创建的而不是打开已有的对象。
int semop(int semid, struct sembuf *sops, unsigned nsops);改变信号量对象中各个信号量的状态。
semid:信号量对象的标识符。
sops:sembuf数组,定义semop()函数所要进行的操作序列。
nsops:sops数组的长度。
一个进程创建并使用信号量:#include <sys/sem.h> union semun { int val; struct semid_ds *buf; unsigned short int *array; struct seminfo *__buf; }; int main() { key_t mykey = ftok(".",'b'); sembuf sops1{0,-1,0}; sembuf sops2{0,1,0}; semun semopts; semopts.val = 1; int sid = semget(mykey, 1, IPC_CREAT | 0660); semctl(sid, 0, SETVAL, semopts); semop(sid, &sops1,1); sleep(5); cout<<"do something"<<endl; semop(sid, &sops2,1); }另一个进程使用信号量:
int main() { key_t mykey = ftok(".",'b'); sembuf sops1{0,-1,0}; sembuf sops2{0,1,0}; int sid = semget(mykey, 1, IPC_CREAT | 0660); semop(sid, &sops1,1); cout<<"another do something "<<endl; semop(sid, &sops2,1); semctl(sid, 0, IPC_RMID, 0); }
输出:
do something
another do something++++++++++++++++共享内存++++++++++++++++
int shmget(key_t key, int size, int shmflg);创建新的或取得已有的共享内存。
key 是共享内存的关键字;
size 是创建的共享内存的大小,以字节为单位。
shmflg 是控制函数行为的标志量,同 msgget()及 semget()函数.
int shmat(int shmid, char *shmaddr, int shmflg);将shmget()函数得到的共享内存,映射到进程自己的内存空间内。
第一个参数是共享内存的标识符。
第二个参数 shmaddr 指定了共享内存映射的地址。
shmflg:
SHM_RND 标志来强迫将内存大小设定为页面的尺寸。
SHM_RDONLY 共享内存将被映射成只读。
int shmctl(int shmqid, int cmd, struct shmid_ds *buf);cmd:
PC_STAT 获得共享内存的信息。
IPC_SET 设定共享内存的信息。
IPC_RMID 删除共享内存。
int shmdt(char *shmaddr);
断开共享内存映射
一个进程发送数据
#include <sys/shm.h>
int main()
{
key_t mykey = ftok(".",'b');
int shmid = shmget(mykey, 100, IPC_CREAT|IPC_EXCL|0666);
char *segptr = (char *)shmat(shmid, 0, 0);
strcpy(segptr, "hello");
}int main()
{
key_t mykey = ftok(".",'b');
int shmid = shmget(mykey, 100, 0);
char *segptr = (char *)shmat(shmid, 0, 0);
cout<<segptr<<endl;
shmctl(shmid, IPC_RMID, 0);
}hello
686
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
