使用 C++ 在 Linux 中停止并重新开始运行进程

Question

我有两个进程和一个共享内存区，我的工作流程是这样的。进程A在共享内存中写入一些数据，之后它应该等待并向其他进程B发送信号开始运行。进程 B 应该从共享内存中读取一些数据，做一些事情写入结果，并向进程 A 发送信号以继续运行，之后进程 B 应该等待。

谁能提供一个例子或一个地方，我可以找到如何停止进程以及如何重新开始运行该进程？我在 Linux 和 C++ 中工作。

我已经有了信号量，但我不喜欢的是，一个进程一直在停止从共享内存中读取的几秒钟，直到它检测到它可以运行。这就是为什么我只想在正确的时刻发出信号

更新解决方案

我选择了 stefan.ciobaca 的答案作为最喜欢的答案，因为它是一个完整的解决方案，它可以工作并且有很好的解释。但在所有其他答案中，还有其他有趣的选项。

Answer 1

以下是如何完成的概念验证：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <assert.h>

typedef void (*sighandler_t)(int); 

#define SHM_SIZE 8  /* size of shared memory: enough for two 32 bit integers */

volatile int cancontinue = 0;

void halt(char *err) { perror(err); exit(1); }
void handler(int signum) { assert(signum == SIGUSR1); cancontinue = 1; }

int main(void)
{
  key_t key;
  int id;
  int *data;
  pid_t otherpid;

  printf("Hi, I am the %s process and my pid is %d\n", 
#ifdef PRODUCER_MODE
  "writer"
#else
  "reader"
#endif
, getpid());
  printf("Please give me the pid of the other process: ");
  scanf("%d", &otherpid);

  // get a pointer to the shared memory
  if ((key = ftok("test_concur.c", 'R')) == -1) halt("ftok");
  if ((id = shmget(key, SHM_SIZE, 0644 | IPC_CREAT)) == -1) halt("shmget");
  if ((data = shmat(id, (void *)0, 0)) == (int *)(-1)) halt("shmat");

  sighandler_t oldhandler = signal(SIGUSR1, handler);

  while (1) {
#ifdef PRODUCER_MODE
    printf("Enter two integers: ");
    scanf("%d %d", data, data + 1);

    printf("Sending signal to consumer process\n");
    kill(otherpid, SIGUSR1);

    printf("Waiting for consumer to allow me to continue\n");
    while (!cancontinue);
    cancontinue = 0;

    if (*data + *(data + 1) == 0) { printf("Sum was 0, exiting...\n"); break; }
#else
    printf("Waiting for producer to signal me to do my work\n");
    while (!cancontinue);
    cancontinue = 0;

    printf("Received signal\n");
    printf("Pretending to do a long calculation\n");
    sleep(1);
    int sum = *data + *(data + 1);
    printf("The sum of the ints in the shared memory is %d\n", sum);

    printf("Signaling producer I'm done\n");
    kill(otherpid, SIGUSR1);

    if (sum == 0) break;
#endif
  }

  signal(SIGUSR1, oldhandler);

  /* detach from the segment: */
  if (shmdt(data) == -1) {
    perror("shmdt");
    exit(1);
  }

  // don't forget to remove the shared segment from the command line with

  // #sudo ipcs
  // ... and look for the key of the shared memory segment

  // #ipcrm -m <key>

  return 0;
}

上面的程序其实是两个程序，一个消费者和一个生产者， 取决于你如何编译它。

您通过确保 PRODUCER_MODE 宏来编译生产者 已定义：

# gcc -Wall -DPRODUCER_MODE -o 生产者 test_concur.c

consumer 编译时没有定义 PRODUCER_MODE 宏：

# gcc -Wall -o 消费者 test_concur.c

消费者和生产者共享一些全局内存（数据指向的8个字节）；生产者的角色是从标准输入中读取两个 32 位整数并将它们写入共享 记忆。消费者从共享内存中读取整数，然后 计算它们的总和。

将数据写入共享内存后，生产者向 消费者（通过 SIGUSR1）它可以开始计算。之后 计算完成后，消费者向生产者发出信号（通过 SIGUSR1 再次）它可能会继续。

当总和为 0 时，两个进程都停止。

目前，每个程序首先输出它的 pid 并从 stdin 另一个程序的 pid。这应该可能 :D 替换为 更智能的东西，具体取决于您在做什么。

此外，在实践中，“while (!cancontinue);”-like 循环应该是 被其他东西取代：D，比如信号量。至少你应该做 每个循环内都有一个小睡眠。另外，我认为您并不真的需要共享内存来解决这个问题，使用消息传递技术应该是可行的。

这是一个示例会话，并行显示：

# ./producer # ./consumer 嗨，我是编写器进程，我的 pid 是 11357 嗨，我是读取器进程，我的 pid 是 11358 请给我其他进程的pid：11358 请给我其他进程的pid：11357 输入两个整数：2 等待生产者通知我做我的工作 3 向消费者进程发送信号接收到的信号 等待消费者允许我继续 假装做一个很长的计算 ...有些时候过去了... 共享内存中的整数之和为 5 信号制作人 我完成了 输入两个整数：0 等待生产者通知我做我的工作 0 向消费者进程发送信号接收到的信号 等待消费者允许我继续 假装做一个很长的计算 ...有些时候过去了... 共享内存中的整数之和为0 信号制作人 我完成了 总和为 0，正在退出...

我希望这会有所帮助。 （运行程序时，确保文件test_concur.c存在（用于建立共享内存密钥（ftok函数调用））

Answer 2

不完全符合您的要求，但您可以使用管道（命名或其他方式）来影响同步吗？这将锁定负担交给已经知道如何操作的操作系统。

只是一个想法。

---

对评论的回应：我的想法是使用管道而不是共享内存来获取更多数据，并免费获得同步。

例如：

1. 进程 A 启动，设置双向管道并使用 popen (3) 分叉进程 B。

2. 分叉之后：

   • A 做了一些工作并写入管道

   • B 尝试读取管道，这将阻塞直到进程 A 写入...

3. 下一步：

   • 尝试读取管道，这将阻塞直到数据可用...

   • B 做了一些工作并写入管道

4. 转到第 2 步，直到达到结束条件。

这不是你要求的。没有共享内存，没有信号，但它应该可以解决问题......

Answer 3

如果将Unix domain sockets 用于 IPC 而不是共享内存呢？这样一来，每个进程都可以在另一个进程工作时阻塞从套接字读取。

编辑：这类似于dmckee's answer，但提供了对阻止和IPC 的更多控制。不过，popen 方法肯定更容易实现。

Answer 4

您真的需要停止进程（退出）并重新启动它，还是只是希望它等到某个事件发生？

如果是后者，您应该阅读 IPC 和进程同步（例如信号量、互斥锁）。

如果是前者，请查看 linux 中类似 init 的源代码。

Answer 5

您要查找的内容称为阻塞。进程 B 应该阻塞来自进程 A 的调用，进程 A 应该阻塞来自进程 B 的调用。如果一个进程被阻塞（等待来自另一个进程的调用），它会闲置在后台，只有在收到时才会唤醒一个消息。

Select 可能是您正在寻找的功能。

Answer 6

我建议使用信号量来同步进程。

阅读标题，我认为 SIGSTOP 和 SIGCONT 可能是可能的，但这可能不是一个好主意；当他们在正确（安全）的地方停下来时，您希望他们停下来。这就是信号量的用途。

许多其他 IPC 机制也可以实现类似的结果，但信号量是跨进程通信机制（您可以在单个进程中的不同线程之间使用互斥锁）。

Answer 7

您可能还想查看boost message queues，它将在后台使用共享内存，但隐藏了所有困难的部分。它提供了阻塞和非阻塞的功能（听起来你想要阻塞）。