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

FreeBSD Manual Pages

  
 
  

home | help
IO::Lambda::Thread(3) User Contributed Perl DocumentationIO::Lambda::Thread(3)

NAME
       IO::Lambda::Thread - wait for blocking code using threads

DESCRIPTION
       The module implements a lambda wrapper that allows to asynchronously
       wait for	a blocking code. The wrapping is done so that the code is
       executed	in another thread's context. "IO::Lambda::Thread" provides
       bidirectional communication between threads, that is based on a shared
       socket between parent and child threads.	The socket can be also used by
       the caller for its own needs, if	necessary ( see	IO::Lambda::Message ).

SYNOPSIS
	   use IO::Lambda qw(:lambda);
	   use IO::Lambda::Thread qw(threaded);

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

API
       new_thread ( $options = (), $code, $pass_socket,	@param)	-> ($thread,
       $socket)
	   A special replacement for "thread-> create",	that not only creates
	   a thread, but also creates a	socket between the parent and child
	   threads. The	socket is important for	getting	an asynchronous
	   notification	when the child thread has finished, because there is
	   no portable way to get that signal otherwise. That means that this
	   socket must be closed and the thread	must be	"join"'ed to avoid
	   problems. For example:

	       my ( $thread, $reader) =	new_thread( $sub {
		   my $writer =	shift;
		   print $writer, "Hello world!\n";
	       }, 1 );
	       print while <$reader>;
	       close($reader);
	       $thread-> join;

	   Note	that "join" is a blocking call,	so one needs to	be sure	that
	   the thread indeed is	finished before	joining	it. By default,	the
	   child thread	closes its side	of the socket, thus making the parent
	   side	readable. However, the child code can also hijack the socket
	   for its own needs, so if that functionality is needed, one must
	   create an extra layer of communication that ensures that the	child
	   code	is properly exited, so that the	parent can reliably call
	   "join" without blocking (see	IO::Lambda::Message, that is destined
	   exactly for this use).

	   $code is executed in	another	thread's context, and is passed	the
	   communication socket	( if $pass_socket is set to 1 ). $code is also
	   passed @param.  Data	returned from the code can be retrieved	from
	   "join".

       threaded($code) :: () ->	( @results )
	   Creates a lambda, that executes $code in a newly created thread.
	   The lambda finishes when the	$code and the thread are finished, and
	   returns results returned by $code.

	   Note, that this lambda, if "terminate"'d between after being
	   started and before being finished, has no chance to wait for
	   completion of the associated	thread,	and so Perl will complain. To
	   deal	with that, obtain the thread object manually and wait for the
	   thread:

	       my $l = threaded	{ 42 };
	       $l-> start;
	       ....
	       $l-> terminate;

	       # synchronously
	       $l-> thread-> join;

	       # or asynchronously
	       context $l-> socket;
	       readable	{ $l-> thread->	join };

       thread($lambda)
	   Returns the associated thread object. Valid only for	lambdas
	   created with	"threaded".

       socket($lambda)
	   Returns the associated communication	socket.	Valid only for lambdas
	   created with	"threaded".

BUGS
       Unbalanced string table refcount
	   Threading in	Perl is	fragile, so errors like	the following:

	      Unbalanced string	table refcount:	(1) for	"GEN1" during global
	      destruction

	   are due to some obscure Perl	bugs. They are triggered, in my
	   experience, when a child thread tries to deallocate scalars that it
	   thinks belongs to that thread.  This	can be sometimes avoided with
	   explicit cleaning up	of scalars that	may be visible in threads.
	   For example,	calls as

	      IO::Lambda::clear

	   and

	      undef $my_lambda;	# or other scalars, whatever

	   inexplicably	hush these errors.

       Perl exited with	active threads
	   Errors like this

	     Perl exited with active threads:
		   1 running and unjoined
		   0 finished and unjoined
		   0 running and detached

	   are triggered when child threads weren't properly joined. Make sure
	   your	lambdas	are finished properly. Use "env
	   IO_LAMBDA_DEBUG=thread" to find out the details.

       Scalars leaked: 1
	   This	is a known bug,	f.ex.
	   <http://rt.perl.org/rt3//Public/Bug/Display.html?id=70974> suggests
	   adding the "@_ = ();" construct at random places as a workaround.

       panic: del_backref during global	destruction
	   This	is a known bug,
	   <http://rt.perl.org/rt3/Ticket/Display.html?id=70748> .  I observed
	   in on win32 only. No	workaround is known however.

       AnyEvent
	   AnyEvent doesn't work with threads, so this module most probably
	   won't work too when AnyEvent	is selected for	IO::Lambda::Loop.

SEE ALSO
       IO::Lambda, threads.

AUTHOR
       Dmitry Karasik, <dmitry@karasik.eu.org>.

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

NAME | DESCRIPTION | SYNOPSIS | API | BUGS | SEE ALSO | AUTHOR

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=IO::Lambda::Thread&sektion=3&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help