1. Linux多进程

• fork

pid_t fork(void); //复制调用进程，并创建为子进程

• wait

pid_t wait(int *status); //等待调用进程的子进程状态变化，此处只考虑结束的情况

2. 示例

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

enum enModules { eMain, eNet, eDB, eBusiness, eLog };
//模拟现实项目的模块
std::map<std::string, int> g_modules = {
    {"net", eNet},
    {"database", eDB},
    {"bussiness", eBusiness},
    {"log", eLog}
};
//子进程的模块参数
std::vector<std::string> params = {"net", "database", "bussiness","log"};

pid_t create_process(std::string program, std::string param, std::map<pid_t, std::string>& tasks)
{
    pid_t pid = fork();
    if(pid == -1)
    {
        std::cout<<"create process failed"<<std::endl;
    }
    else if(pid != 0) //父进程
    {
        tasks[pid] = param;
        return pid;
    }

    if(execlp(program.c_str(), program.c_str(), param.c_str(), NULL))
	{
        std::cout<<"execlp error"<<std::endl;
    }
}

int main(int argc, char** argv) 
{
    int status;
    std::map<pid_t, std::string> task_map; //map <进程ID, 参数>

    std::string program = argv[0];
    std::string cmd = argc>1 ? argv[1] : "main";

    switch (g_modules[cmd])
    {
        case eMain:
            //fork不能使用循环or迭代器
            create_process(program, params[0], task_map);
            create_process(program, params[1], task_map);
            create_process(program, params[2], task_map);
            create_process(program, params[3], task_map);
            break;
        case eNet:
        case eDB:
        case eBusiness:
        case eLog:
            while (1)
                sleep(10);
            break;
        default:
            break;
    }
    
	//守护子进程
    while (true)
    {
        pid_t pid = wait(&status);
        if(pid == -1)
            return -1;
        create_process(program, task_map[pid], task_map);
    }
    return 0;
}

3. 总结

合理利用fork能创造出符合模块化的多进程设计，并自带守护进程的程序，对于嵌入式应用来说是非常值得借鉴的。