Threads & Fork

[Jonathan Bryant <jtbryant@valdosta.edu>]

[-- Attachment #1: Type: text/plain, Size: 1365 bytes --]

I'm confused as to why the attached code hangs.  My understanding of
Unix.fork () is that it completely clones the current process, which in
my understanding, clones the processes's threads as well.  Apparently,
though, that is not the case, because I can't join the thread in both
the parent and the child.  Are threads created external to the process? 
I've played around with the source code and I've found that I can only
join the thread in the parent process (i.e., if I remove the Thread.join
from the parent process, it still hangs).

Can someone explain this behavior?  I'm needing to create several
multi-threaded worker processes, and it would be much easier if I could
simply create one, have it wait for a signal, and, on that signal, fork
a clone of itself.  Also, I'm needing to fork a process from in the
middle of a multi-threaded application, so I assumed that my new process
needed to join all of the threads and close all of the file
descriptors.  Is this not the case?

-- 
--Jonathan Bryant
  jtbryant@valdosta.edu
  Student Intern
  Unix System Operations
  VSU Information Technology

"Das Leben ohne Music ist einfach ein Irrtum, eine Strapaze, ein" Exil."
("Life without music is simply an error, a pain, an exile.")
--Frederich Nietzsche

"The three cardinal values of a programmer are laziness, impatience, and
hubris."
--Perl Man Page



[-- Attachment #2: threadTest.ml --]
[-- Type: text/plain, Size: 944 bytes --]

(**
 * A simple thread + fork test.  Compile as:
 * ocamlopt.opt -threads -o threadTest unix.cmxa threads.cmxa threadTest.ml
 *)

let () =
    (* Create a thread to join *)
    let t = Thread.create (fun x -> ()) () in
    Printf.printf "Thread created.\n"; flush stdout;

    (* Fork a new process *)
    match Unix.fork () with
    | 0 ->
        (* Join the thread in the child process and exit *)
        Printf.printf "Child process created.\n"; flush stdout;
        Thread.join t;
        Printf.printf "Child joined thread.\n"; flush stdout;
        exit 0
    | _ as pid ->
        (* Join the thread and the child in the parent process and exit *)
        Printf.printf "Parent process continuing.\n"; flush stdout;
        Thread.join t;
        Printf.printf "Parent joined thread.\nWaiting on child.\n";
        flush stdout;
        let _ = Unix.waitpid [] pid in
        Printf.printf "Child joined.  Exiting.\n";
        exit 0