create and kill child process on linux

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>

class ProcessMap
{
private:
  map<std::string, pid_t> m_process_map;

public:

const bool create_process(const std::string& process_name, const std::string& user_name);

const bool remove_process(const std::string& user_name);
};

//create child process and add to process map
const bool ProcessMap::create_process(const std::string& process_name, const std::string& user_name)
{
    QMServerMap::remove_process(user_name);

    pid_t pID = fork();
    if (pID == 0)
    {
                //you can add arguments for the child process if you like
        execl(process_name, NULL);
    }
    else if (pID < 0)
    {
        // failed to fork
        return false;
    }
    else
    {
        // parent
        m_process_map[user_name] = pID;
    }
    return true;
}


//delete child process and remove from the process map
const bool QMServerMap::remove_process(const std::string& user_name)
{
    if (m_process_map.find(user_name)!=m_process_map.end())
    {
        pid_t pid = m_process_map[user_name];
        if (pid > 0)
        {
            kill(pid,SIGTERM);
            waitpid(pid, NULL, 0);
        }
        m_process_map.erase(user_name);

        return true;
    }
    return false;
}

 

1. 如果子进程未结束， 父进程仍在执行， kill 子进程之后， 调用waitpid 读取子进程状态， 可以避免僵死进程

 

2. 如果子进程已经退出， 父进程仍在执行且未调用remove process ， 此时子进程为僵死进程， 可以通过调用 remove process 删除僵死子进程

 

 A better way to avoid zombie child process

 

 

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>

class ProcessMap
{
private:
  static map<std::string, pid_t> m_process_map;

public:

static void create_process(const std::string& process_name, const std::string& user_name);

static void remove_process(const std::string& user_name);

static void zombie_handler(int signal);
};

void ProcessMap::zombie_handler(int signal)
{
    int status;
    pid_t pid = wait(&status);
    map<string, pid_t>::iterator iter;
    for(iter = m_process_map.begin(); iter!=m_process_map.end(); ++iter)
        if (iter->second == pid)
        {
            m_process_map.erase();
            return;
        }
}

//create child process and add to process map
void ProcessMap::create_process(const std::string& process_name, const std::string& user_name)
{
    if (m_process_map.find(user_name)!=m_process_map.end())
        return;

    signal(SIGCHLD, zombie_handler);

    pid_t pID = fork();
    if (pID == 0)
    {
        //you can add arguments for the child process if you like
        execl(process_name, NULL);
    }
    else if (pID < 0)
    {
        // failed to fork
        return;
    }
    else
    {
        // parent
        m_process_map[user_name] = pID;
    }
}


//kill child process
void QMServerMap::remove_process(const std::string& user_name)
{
    if (m_process_map.find(user_name)!=m_process_map.end())
            kill(m_process_map[user_name],SIGTERM);
 }

1. signal(SIGCHLD, zombie_handler) ; 注册zombie_handler 来处理 子进程结束事件， 调用wait, 删除zombie process