Path: csiph.com!v102.xanadu-bbs.net!xanadu-bbs.net!goblin2!goblin.stu.neva.ru!newsfeed.xs4all.nl!newsfeed4.news.xs4all.nl!xs4all!post.news.xs4all.nl!not-for-mail
MIME-Version: 1.0
Date: Sun, 13 Jul 2014 19:53:09 -0400
Subject: Multiprocessing question
From: Paul LaFollette <paul.lafollette@gmail.com>
To: python-list@python.org
Content-Type: multipart/alternative; boundary=089e0139fa8a6ce52a04fe1be064
Precedence: list
Newsgroups: comp.lang.python
Message-ID: <mailman.11791.1405295598.18130.python-list@python.org>
Lines: 186
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: csiph.com comp.lang.python:74406

--089e0139fa8a6ce52a04fe1be064
Content-Type: text/plain; charset=UTF-8

Kind people,
I have thrown together a little C/UNIX program that forks a child process,
then proceeds to let the child and parent alternate.  Either can run until
it pauses itself and wakes the other.

I would like to know if there be a way to create the same behavior in
Python 3, preferably in a non-platform dependent fashion.  I would prefer
to use processes rather than threads, but could live with threads if I had
to.  I've studied the documentation for the multiprocessing and thread
modules, but I can't see an easy way to do what I want to do.  I need
minimal communication between processes beyond what i have described, so
creating queues or pipes seems like overkill.  Unlike what I have written
here, I will want to exec the child rather than write the whole thing in
the else clause.  Is there a reasonably simple way to do this?  A reference
to useful documentation would be appreciated.  Sample code even more so, of
course.
Thank you
Paul

-------------------------
Paul S. LaFollette, Jr
CIS Department
Temple University
+1 215 204 6822
paul.lafollette@temple.edu
http://knight.cis.temple.edu/~lafollet

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <errno.h>

int main(int argc, char **argv)
{
  void handler(int);
  pid_t pid;

  signal(SIGCONT, handler);

  pid = fork();
  if (pid < 0) //failure
  {
    printf("Unable to fork\n");
    exit(1);
  }
  else if (pid > 0) // parent
  {
    while (1)
    {
      printf("Parent waiting for child to do something\n");
      pause();
      printf("Parent doing nifty stuff.\n");
      sleep(1);
      printf("Parent waking child\n");
      errno = 0;
      if (kill(pid, SIGCONT) < 0)
        perror("Parent failed to SIGCONT child.");
    }
  }
  else //pid == 0 so child
  {
    while (1)
    {
      printf ("                                    Child doing useful
work.\n");
      sleep(1);
      printf("                                     Child waking parent\n");
      if (kill(getppid(), SIGCONT) < 0)
        perror("Child failed to SIGCONT parent.");
      printf("                                     Child waiting for parent
to do something\n");
      pause();
    }
  }
}

void handler(int signum)
{
}
===============================================================================
Output:
Parent waiting for child to do something
                                    Child doing useful work.
                                     Child waking parent
                                     Child waiting for parent to do
something
Parent doing nifty stuff.
Parent waking child
Parent waiting for child to do something
                                    Child doing useful work.
                                     Child waking parent
                                     Child waiting for parent to do
something
Parent doing nifty stuff.
Parent waking child
Parent waiting for child to do something
                                    Child doing useful work.
                                     Child waking parent
                                     Child waiting for parent to do
something

--089e0139fa8a6ce52a04fe1be064
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: base64
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--089e0139fa8a6ce52a04fe1be064--