linux 多进程编程详解
1.创建进程fork()
1.1头文件
#include<unistd.h>
#include<sys/types.h> 1.2函数原型
pid_t fork( void);pid_t 是一个宏定义，其实质是int 被定义在#include
1.3 返回值：
若成功调用一次则返回两个值，子进程返回0，父进程返回子进程ID；否则，出错返回-1
1.4 注意以下几点
在Linux系统中创建进程有两种方式：一是由操作系统创建，二是由父进程创建进程（通常为子进程）。系统调用函数fork()是创建一个新进程的唯一方式，当然vfork()也可以创建进程，但是实际上其还是调用了fork()函数。fork()函数是Linux系统中一个比较特殊的函数，其一次调用会有两个返回值。
调用fork()之后，父进程与子进程的执行顺序是我们无法确定的（即调度进程使用CPU），意识到这一点极为重要，因为在一些设计不好的程序中会导致资源竞争，从而出现不可预知的问题。
fork产生子进程的表现就是它会返回2次，一次返回0，顺序执行下面的代码。这是子进程。一次返回子进程的pid，也顺序执行下面的代码，这是父进程。
进程创建成功之后，父进程以及子进程都从fork() 之后开始执行，知识pid不同。fork语句可以看成将程序切为A、B两个部分。（在fork()成功之后，子进程获取到了父进程的所有变量、环境变量、程序计数器的当前空间和值）。
一般来说，fork()成功之后，父进程与子进程的执行顺序是不确定的。这取决于内核所使用的调度算法，如果要求父子进程相互同步，则要求某种形式的进程间通信。
1.5 vfork()函数
也用于创建一个进程，返回值与fork()相同。
fork()与vfork()的异同
执行次序：
fork():对父子进程的调度室由调度器决定的；
vfork():是先调用子进程，等子进程的exit(1)被调用后，再调用父进程；-
对数据段的影响：
fork():父子进程不共享一段地址空间，修改子进程，父进程的内容并不会受 影响。vfork():在子进程调用exit之前，它在父进程的空间中运行，也就是说会更改 父进程的数据段、栈和堆。。即共享代码区和数据区，且地址和内容都是一 样的。
2.父进程和子进程异同点
1.相同点
创建子进程之后，子进程拷贝了父进程所有的变量，并且子进程修改变量的值，并不影响父进程的变量值。
2.不同点
fork()的返回值不同。
进程ID不同
3.代码示例
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <vector>
#include <iostream>
#include<sys/wait.h>
using namespace std;
// 进程退出函数
void print_exit()
{
printf("the exit pid:[%d] \n",getpid() );
}
int main()
{
string sMatch;
pid_t pid, child_pid;
vector<string> provList;
provList.push_back("taskFace");
provList.push_back("taskObj");
provList.push_back("taskAction");
provList.push_back("taskHat");
provList.push_back("taskOther");
cout << "Main process,id=" << getpid() << endl;
// 循环处理"100,200,300,400,500"
for (vector<string>::iterator it = provList.begin(); it != provList.end(); ++it)
{
sMatch = *it;
atexit( print_exit );
pid = fork();
// (*hsq*)子进程退出循环，不再创建子进程，全部由主进程创建子进程，这里是关键所在
if(pid == 0 || pid == -1)
{
break;
}
}
if(pid == -1)
{
cout<<"Fail to fork!"<<endl;
exit(1);
}
else if(pid == 0)
{
// 这里写子进程处理逻辑
cout <<"This is children process,id=" << getpid() << ",start to process " << sMatch << endl;
sleep(10);
exit(0);
}
else
{
// 这里主进程处理逻辑
cout << "This is main process,id=" << getpid() <<",end to process "<< sMatch << endl;
do
{
// WNOHANG 非阻塞 轮询 等待带子进程结束
child_pid = waitpid(pid, NULL, WNOHANG);
if(child_pid != pid)
{
printf("---- watpid error!\n");
}
printf("I am main progress.The pid progress has not exited!\n");
sleep(2);
}while(child_pid == 0);
exit(0);
}
return 0;
}执行结果
4.父进程子进程从哪里开始执行的问题
#include <unistd.h>
#include <sys/types.h>
main ()
{
pid_t pid;
printf("hello!\n");
pid=fork();
if (pid < 0)
printf("error in fork!");
else if (pid == 0)
printf("i am the child process, my process id is %d\n ",getpid());
else
printf("i am the parent process, my process id is %d\n",getpid());
printf("bye!\n");
} 这里可以看出parent process执行了printf(“hello!\n”); 而child process 没有执行printf(“hello!\n”);
有一个让人很迷惑的例子：
#include <unistd.h>
#include <sys/types.h>
main ()
{
pid_t pid;
printf("fork!"); //printf("fork!\n")
pid=fork();
if (pid < 0)
printf("error in fork!\n");
else if (pid == 0)
printf("i am the child process, my process id is %d\n",getpid());
else
printf("i am the parent process, my process id is %d\n",getpid());
} 此时打印输出了两个fork！这不免让人以为是child process从#include处开始执行，所以也执行了printf(“fork!”); 语句。
其实不然，出现这种问题的原因在于：
这就跟Printf的缓冲机制有关了,printf某些内容时,操作系统仅仅是把该内容放到了stdout的缓冲队列里了,并没有实际的写到屏幕上 。但是,只要看到有\n, 则会立即刷新stdout,因此就马上能够打印了.mian函数(parent process)运行了printf(“fork!”) 后, “fork!”仅仅被放到了缓冲里,再运行到fork时,缓冲里面的 AAAAAA 被子进程(child process)继承了,因此在子进程度stdout缓冲里面就也有了”fork!”。所以,你最终看到的会是 “fork!” 被printf了2次!!!! 而mian函数(parent process)运行 printf(“fork!\n”)后,”fork!” 被立即打印到了屏幕上,之后fork到的子进程(child process)里的stdout缓冲里不会有”fork!”内容 因此你看到的结果会是”fork!” 被printf了1次!!!!
5.进程间通信
1.示例代码（以消息队列为例）
#include <stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include <sys/types.h>
#include<vector>
#include <iostream>
#include<sys/wait.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/msg.h>
using namespace std;
typedef struct TASK_LIST_
{
int taskId;
const char *taskInfo;
}TASK_LIST;
void print_exit()
{
printf("the exit pid:[%d] \n",getpid() );
}
TASK_LIST taskList[5];
#define SIZE 1024
const long id = 1;
int main(int argc, char const *argv[])
{
key_t unique_key;
int msgid;
int status;
char str[SIZE];
struct msgbuf
{
long msgtype;
char msgtext[SIZE];
}sndmsg, rcvmsg;
TASK_LIST sMatch;
pid_t pid, child_pid;
//int status;
vector<TASK_LIST> provList;
taskList[0].taskInfo = "1001";
taskList[1].taskInfo = "2002";
taskList[2].taskInfo = "3003";
taskList[3].taskInfo = "4004";
taskList[4].taskInfo = "5005";
for (int i = 0; i < 5; i++)
{
cout << i << " " << taskList[i].taskInfo << endl;
taskList[i].taskId = i;
provList.push_back(taskList[i]);
}
cout<<"main process,id="<<getpid()<<endl;
// 创建一个消息队列
// IPC_CREAT :创建一个消息队列 IPC_EXCL :如果已经存在则报错
msgid = msgget(unique_key,IPC_CREAT | IPC_EXCL);
for (int i = 0; i < provList.size(); i++)
{
atexit( print_exit );
pid = fork();
// (*hsq*)子进程退出循环，不再创建子进程，全部由主进程创建子进程，这里是关键所在
if (pid == 0 || pid == -1)
{
break;
}
}
if(pid == -1)
{
cout<<"fail to fork!"<<endl;
msgctl(msgid, IPC_RMID, 0);
exit(1);
}
else if(pid == 0)
{
sleep(5);
if((status = msgrcv(msgid, (struct msgbuf *)&rcvmsg, sizeof(str) + 1, id, IPC_NOWAIT)) == -1)
{
fprintf(stderr, "msgrcv error!\n");
exit(4);
}
int taskId = atoi(rcvmsg.msgtext);
if(taskId == 1)
{
cout << "start task [" << taskList[1].taskId <<"] :" << taskList[1].taskInfo << endl;
}
printf("The received message is:%s\n", rcvmsg.msgtext);
// msgctl(msgid, IPC_RMID, 0); // delete the message queue
//这里写子进程处理逻辑
cout << "this is children process,id=" << getpid() << endl;
sleep(2);
exit(0);
}
else
{
cout << "this is main process,pid=" << getpid() << endl;
sleep(3);
for (int i = 0; i < 5; ++i)
{
sndmsg.msgtype = id;
char id[4];
sprintf(id, "%d", i);
strcpy(str, id);
sprintf(sndmsg.msgtext, str);
if(msgsnd(msgid, (struct msgbuf *)&sndmsg, sizeof(str) + 1, 0) == -1)
{
fprintf(stderr, "msgsnd error! \n");
exit(2);
}
}
// 这里主进程处理逻辑
// do
// {
// // WNOHANG 非阻塞 轮询 等你带子进程结束
// child_pid = waitpid(pid, NULL, WNOHANG);
// if(child_pid != pid)
// {
// printf("---- watpid error!\n");
// }
// printf("I am main progress.The pid progress has not exited!\n");
// sleep(2);
// }while(child_pid == 0);
// exit(0);
}
return 0;
}2.接口分析
1.1msgget函数
该函数用来创建和访问一个消息队列
int msgget(key_t, key, int msgflg);
与其他的IPC机制一样，程序必须提供一个键来命名某个特定的消息队列。msgflg是一个权限标志，表示消息队列的访问权限，它与文件的访问权限一样。msgflg可以与IPC_CREAT做或操作，表示当key所命名的消息队列不存在时创建一个消息队列，如果key所命名的消息队列存在时，IPC_CREAT标志会被忽略，而只返回一个标识符，它返回一个以key命名的消息队列的标识符（非零整数），失败时返回-1.
1.2msgsnd函数
该函数用来把消息添加到消息队列中。
int msgsend(int msgid, const void *msg_ptr, size_t msg_sz, int msgflg);msgid是由msgget函数返回的消息队列标识符。
msg_ptr是一个指向准备发送消息的指针，但是消息的数据结构却有一定的要求，指针msg_ptr所指向的消息结构一定要是以一个长整型成员变量开始的结构体，接收函数将用这个成员来确定消息的类型。所以消息结构要定义成这样：
struct my_message
{
long int message_type;
/* The data you wish to transfer*/
};msg_sz是msg_ptr指向的消息的长度，注意是消息的长度，而不是整个结构体的长度，也就是说msg_sz是不包括长整型消息类型成员变量的长度。
msgflg用于控制当前消息队列满或队列消息到达系统范围的限制时将要发生的事情。
如果调用成功，消息数据的一分副本将被放到消息队列中，并返回0，失败时返回-1.
1.3 msgrcv函数
该函数用来从一个消息队列获取消息，它的原型为
int msgrcv(int msgid, void *msg_ptr, size_t msg_st, long int msgtype, int msgflg);
msgid, msg_ptr, msg_st的作用也函数msgsnd函数的一样。
msgtype可以实现一种简单的接收优先级。如果msgtype为0，就获取队列中的第一个消息。如果它的值大于零，将获取具有相同消息类型的第一个信息。如果它小于零，就获取类型等于或小于msgtype的绝对值的第一个消息。
msgflg用于控制当队列中没有相应类型的消息可以接收时将发生的事情。
调用成功时，该函数返回放到接收缓存区中的字节数，消息被复制到由msg_ptr指向的用户分配的缓存区中，然后删除消息队列中的对应消息。失败时返回-1.
1.4msgctl函数
该函数用来控制消息队列，它与共享内存的shmctl函数相似，它的原型为：
int msgctl(int msgid, int command, struct msgid_ds *buf);
command是将要采取的动作，它可以取3个值，
IPC_STAT：把msgid_ds结构中的数据设置为消息队列的当前关联值，即用消息队列的当前关联值覆盖msgid_ds的值。
IPC_SET：如果进程有足够的权限，就把消息列队的当前关联值设置为msgid_ds结构中给出的值
IPC_RMID：删除消息队列
buf是指向msgid_ds结构的指针，它指向消息队列模式和访问权限的结构。msgid_ds结构至少包括以下成员：
struct msgid_ds
{
uid_t shm_perm.uid;
uid_t shm_perm.gid;
mode_t shm_perm.mode;
};成功时返回0，失败时返回-1.
以上内容是作者在学习中，参考他人经验，以及《Unix高级环境编程》等书籍总结而来，希望可以对正在学习这部分的初学者有所帮助。欢迎交流，共同学习！
上一篇： Python多进程共享变量
下一篇： 如何创建只读权限oracle账户