Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
IO::Lambda::Fork(3)   User Contributed Perl Documentation  IO::Lambda::Fork(3)

       IO::Lambda::Fork	- wait for blocking code in children processes

       The module implements the lambda	wrapper	that allows to wait
       asynchronously for blocking code	in another process' context.
       "IO::Lambda::Fork" provides a twofold interface for that: the lambda
       interface, that can wait	for the	forked child processes,	and an easier
       way for simple communication between these.

       Contrary	to the classical stdin-stdout interaction between parent and
       child processes,	this module establishes	a stream socket	and uses it
       instead.	The socket can also be used by the caller for its own needs (
       see IO::Lambda::Message ).

	   use IO::Lambda qw(:lambda);
	   use IO::Lambda::Fork	qw(forked);

       Blocking	wait

	   lambda {
	       context forked {
		   return "hello!";
	       tail {
		   print shift,	"\n"
	   }-> wait;

	   # hello!

       Non-blocking wait

	   lambda {
	       context 0.1, forked {
		     return "hello!";
	       any_tail	{
		   if (	@_) {
		       print "done: ", $_[0]-> peek, "\n";
		   } else {
		       print "not yet\n";
	   }-> wait;

	   # not yet
	   # not yet
	   # not yet
	   # done: hello!

       (of course, since IO::Lambda is inherently non-blocking,	the first
       example is of much more use, as many of such "blocking" lambdas can
       execute in parallel)

       new_process($code, $pass_socket,	@param)	-> ( $pid, $socket | undef,
       $error )
	   Forks a process, and	sets up	a read-write socket between the	parent
	   and the child. On success, returns the child's pid and the socket,
	   where the latter is passed further to $code.	On failure, returns
	   undef and $!.

	   This	function does not create a lambda, neither makes any
	   preparations	for waiting for	the child process, nor for reaping its
	   status. It is therefore important for the caller itself to wait for
	   the child process, to avoid zombie processes. That can be done
	   either synchronously:

	       my ( $pid, $reader) = new_process {
		   my $writer =	shift;
		   print $writer, "Hello world!\n";
	       print while <$reader>;
	       waitpid($pid, 0);

	   or asynchronously, using "waitpid" wrappers from

	       use IO::Lambda::Signal qw(pid new_pid);
	       lambda {	context	$pid; &pid() }-> wait;
	       # or
	       new_pid($pid)-> wait;

       process($code) :: () -> ($? | undef)
	   Creates a simple lambda that	forks a	process	and executes $code
	   inside it.  The lambda returns the child exit code.

       new_forked($code) :: () -> ( $?,	( 1, @results |	undef, $error))
	   Creates a lambda that awaits	for $code in a sub-process to be
	   executed, then returns the code' result back	to the parent. Returns
	   also	the process exitcode, $code eval success flag, and an array of
	   code	results	or an error string, if any.

       forked($code) ::	() -> (@results	| $error)
	   A simple wrapper over "new_forked", that returns either $code
	   results or an error string.

       Doesn't work on Win32, because relies on	$SIG{CHLD} which is not
       getting delivered (on 5.10.0 at least). However,	since Win32 doesn't
       have forks anyway, Perl emulates	them with threads. Consider using
       IO::Lambda::Thread instead when running on windows.

       Has issues with SIGCHLD on perls	< 5.8.0.

       Dmitry Karasik, <>.

perl v5.32.0			  2012-03-14		   IO::Lambda::Fork(3)


Want to link to this manual page? Use this URL:

home | help