linux 挂起进程

Posted 2023-04-25

1 我在终端输入Xclock 命令后，光标会一直处于图片中表黄区域，请问如何使其恢复正常，在终端上使用什么命令会使Xclock 这个进程直接进入后台并运行（不是挂起）。

在线等 谢谢！

楼上的回答很好，答案就是这个：nohup xclock &
我来解释下： 命令后带上 & 就是进入后台执行的意思
那么为什么要 nohup呢，因为如果终端关闭，这个xclock程序也会关闭，用是为了不会挂断

另外你提到的挂起，我想应该是指 ctrl+z，这个是暂停程序放到后台，就是挂起的意思，然后可以用fg和bg前后台切换。 参考技术A nohup xclock &

Linux：fork & execv，等待子进程挂起

【中文标题】Linux：fork & execv，等待子进程挂起

【英文标题】：Linux: fork & execv, wait for child process hangs

【发布时间】：2014-11-17 11:25:49

【问题描述】：

受answer 的启发，我编写了一个辅助函数来使用 fork() 和 execv() 启动进程。它用于启动例如mysqldump 进行数据库备份。 该代码在具有不同程序的几个不同位置完全可以正常工作。

现在我遇到了一个失败的星座： 这是对 systemctl 的调用以停止一个单元。运行 systemctl 工作，单元停止。但是在中间进程中，当为子进程wait()时，wait()会一直挂起，直到超时进程结束。 如果我检查，如果工作进程使用 kill() 完成，我可以知道它完成了。

重要提示：程序没有异常行为或段错误，除了 wait() 不会发出工作进程结束的信号！ 我的代码（见下文）中是否有任何不正确的可能触发该行为的内容？ 我已阅读 Threads and fork(): think twice before mixing them，但我在其中找不到与我的问题相关的任何内容。

有什么奇怪的： 深，深，深在使用 JSON-RPC 的程序中。如果我使用 JSON-RPC 停用代码一切正常！？

环境： 使用该函数的程序是一个多线程应用程序。所有线程的信号都被阻塞。主线程通过 sigtimedwait() 处理信号。

带有示例 main 函数的代码（通过 std::cout 将日志记录换成输出的生产代码）：

#include <iostream>

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

namespace 

bool checkStatus(const int status) 
    return( WIFEXITED(status) && ( WEXITSTATUS(status) == 0 ) );




bool startProcess(const char* const path, const char* const argv[], const unsigned int timeoutInSeconds, pid_t& processId, const int* const fileDescriptor) 
    auto result = true;

    const pid_t intermediatePid = fork();
    if(intermediatePid == 0) 
        // intermediate process
        std::cout << "Intermediate process: Started (" <<  getpid() << ")." << std::endl;
        const pid_t workerPid = fork();
        if(workerPid == 0) 
            // worker process
            if(fileDescriptor) 
                std::cout << "Worker process: Redirecting file descriptor to stdin." << std::endl;
                const auto dupResult = dup2(*fileDescriptor, STDIN_FILENO);
                if(-1 == dupResult) 
                    std::cout << "Worker process: Duplication of file descriptor failed." << std::endl;
                    _exit(EXIT_FAILURE);
                
            
            execv(path, const_cast<char**>(argv));

            std::cout << "Intermediate process: Worker failed!" << std::endl;
            _exit(EXIT_FAILURE);
         else if(-1 == workerPid) 
            std::cout << "Intermediate process: Starting worker failed!" << std::endl;
            _exit(EXIT_FAILURE);
        

        const pid_t timeoutPid = fork();
        if(timeoutPid == 0) 
            // timeout process
            std::cout << "Timeout process: Started (" << getpid() << ")." << std::endl;
            sleep(timeoutInSeconds);
            std::cout << "Timeout process: Finished." << std::endl;
            _exit(EXIT_SUCCESS);
         else if(-1 == timeoutPid) 
            std::cout << "Intermediate process: Starting timeout process failed." << std::endl;
            kill(workerPid, SIGKILL);
            std::cout << "Intermediate process: Finished." << std::endl;
            _exit(EXIT_FAILURE);
        

        // ---------------------------------------
        // This code is only used for double checking if the worker is still running.
        // The if condition never evaluated to true in my tests.
        const auto killResult = kill(workerPid, 0);
        if((-1 == killResult) && (ESRCH == errno)) 
            std::cout << "Intermediate process: Worker is not running." << std::endl;
        
        // ---------------------------------------

        std::cout << "Intermediate process: Waiting for child processes." << std::endl;
        int status = -1;
        const pid_t exitedPid = wait(&status);

        // ---------------------------------------
        // This code is only used for double checking if the worker is still running.
        // The if condition evaluates to true in the case of an error.
        const auto killResult2 = kill(workerPid, 0);
        if((-1 == killResult2) && (ESRCH == errno)) 
            std::cout << "Intermediate process: Worker is not running." << std::endl;
        
        // ---------------------------------------

        std::cout << "Intermediate process: Child process finished. Status: " <<  status << "." << std::endl;
        if(exitedPid == workerPid) 
            std::cout << "Intermediate process: Killing timeout process." << std::endl;
            kill(timeoutPid, SIGKILL);
         else 
            std::cout << "Intermediate process: Killing worker process." << std::endl;
            kill(workerPid, SIGKILL);
            std::cout << "Intermediate process: Waiting for worker process to terminate." << std::endl;
            wait(nullptr);
            std::cout << "Intermediate process: Finished." << std::endl;
            _exit(EXIT_FAILURE);
        
        std::cout << "Intermediate process: Waiting for timeout process to terminate." << std::endl;
        wait(nullptr);
        std::cout << "Intermediate process: Finished." << std::endl;
        _exit(checkStatus(status) ? EXIT_SUCCESS : EXIT_FAILURE);

     else if(-1 == intermediatePid) 
        // error
        std::cout << "Parent process: Error starting intermediate process!" << std::endl;
        result = false;
     else 
        // parent process
        std::cout << "Parent process: Intermediate process started. PID: " << intermediatePid << "." << std::endl;
        processId = intermediatePid;
    

    return(result);


bool waitForProcess(const pid_t processId) 
    int status = 0;
    const auto waitResult = waitpid(processId, &status, 0);
    auto result = false;
    if(waitResult == processId) 
        result = checkStatus(status);
    
    return(result);


int main() 
    pid_t pid = 0;
    const char* const path = "/bin/ls";
    const char* argv[] =  "/bin/ls", "--help", nullptr ;
    const unsigned int timeoutInS = 5;
    const auto startResult = startProcess(path, argv, timeoutInS, pid, nullptr);
    if(startResult) 
        const auto waitResult = waitForProcess(pid);
        std::cout << "waitForProcess returned " << waitResult << "." << std::endl;
     else 
        std::cout << "startProcess failed!" << std::endl;
    

编辑

预期的输出应该包含

中间进程：等待子进程。 中间进程：子进程已完成。状态：0。 中间进程：杀死超时进程。

如果出现错误，输出如下所示

中间进程：等待子进程。 中间进程：子进程已完成。状态：-1 中间进程：杀死工作进程。

当您运行示例代码时，您很可能会看到预期的输出。我无法在一个简单的例子中重现错误的结果。

【问题讨论】：

当父级被wait屏蔽时，子级是否显示为僵尸？

我编译并运行了代码，我认为没有奇怪的行为，你能提供expected result和current result吗？

@Useless：没有僵尸进程。 ps -l 返回例如中间进程 ID 617，超时进程 ID 619，但根本没有 618。我在代码中使用 kill() 进行的测试产生了相同的结果。

@Kir Chou：该示例显示了所需的行为。奇怪的是，我只在成熟的应用程序中遇到问题，而且只有在使用 JSON-RPC 的情况下。否则它工作。我发布了代码以供审查，所以也许有人可以指出我实现它的方式不安全或不正确的地方。

【参考方案1】：

我发现了问题：

在函数mg_start的猫鼬（JSON-RPC使用猫鼬）源中，我找到了以下代码

#if !defined(_WIN32) && !defined(__SYMBIAN32__)
  // Ignore SIGPIPE signal, so if browser cancels the request, it
  // won't kill the whole process.
  (void) signal(SIGPIPE, SIG_IGN);
  // Also ignoring SIGCHLD to let the OS to reap zombies properly.
  (void) signal(SIGCHLD, SIG_IGN);
#endif // !_WIN32

(void) signal(SIGCHLD, SIG_IGN);

原因

如果父进程执行了一个wait()，这个调用只有在所有子进程都退出后才会返回，然后返回-1并将errno设置为ECHILD。”

如 5.5 Voodoo：等待和 SIGCHLD 部分中提到的here。

这在 WAIT(2) 的手册页中也有描述

错误 [...]

ECHILD [...]（这可能发生在 如果 SIGCHLD 的操作设置为 SIG_IGN，则为自己的孩子。 另请参阅有关线程的 Linux 说明部分。）

没有正确检查返回值是我的愚蠢。 尝试之前

if(exitedPid == workerPid) 

我应该检查一下 exitedPid 是 != -1。

如果我这样做，errno 会给我ECHILD。如果我一开始就知道这一点，我会阅读手册页并可能更快地发现问题......

猫鼬的顽皮只是为了搞乱信号处理，不管应用程序想要做什么。此外，当使用 mg_stop 停止时，mongoose 不会恢复信号处理的更改。

其他信息： 导致此问题的代码已于 2013 年 9 月在 mongoose 中更改为 this commit。

【参考方案2】：

在我们的应用程序中，我们遇到了类似的问题。在重复子进程 forks() 的激烈情况下，子进程永远不会返回。可以监视子进程的 PID，如果它没有返回超过特定应用程序定义的阈值，您可以通过发送 kill/Term 信号来终止该进程。