MirBSD manpage: threads(3p)

ext::threads::thrPerl(Programmers Refereext::threads::threads(3p)


     threads - Perl extension allowing use of interpreter based
     threads from perl


         use threads;

         sub start_thread {
             print "Thread started\n";

         my $thread  = threads->create("start_thread","argument");
         my $thread2 = $thread->create(sub { print "I am a thread"},"argument");
         my $thread3 = async { foreach (@files) { ... } };


         $thread = threads->self();
         $thread = threads->object( $tid );





     Perl 5.6 introduced something called interpreter threads.
     Interpreter threads are different from "5005threads" (the
     thread model of Perl 5.005) by creating a new perl inter-
     preter per thread and not sharing any data or state between
     threads by default.

     Prior to perl 5.8 this has only been available to people
     embedding perl and for emulating fork() on windows.

     The threads API is loosely based on the old Thread.pm API.
     It is very important to note that variables are not shared
     between threads, all variables are per default thread local.
     To use shared variables one must use threads::shared.

     It is also important to note that you must enable threads by
     doing "use threads" as early as possible in the script
     itself and that it is not possible to enable threading
     inside an "eval """, "do", "require", or "use".  In particu-
     lar, if you are intending to share variables with
     threads::shared, you must "use threads" before you "use
     threads::shared" and "threads" will emit a warning if you do
     it the other way around.

perl v5.8.8                2005-02-05                           1

ext::threads::thrPerl(Programmers Refereext::threads::threads(3p)

     $thread = threads->create(function, LIST)
         This will create a new thread with the entry point func-
         tion and give it LIST as parameters.  It will return the
         corresponding threads object, or "undef" if thread crea-
         tion failed. The new() method is an alias for create().

         This will wait for the corresponding thread to join.
         When the thread finishes, join() will return the return
         values of the entry point function. If the thread has
         been detached, an error will be thrown.

         The context (void, scalar or list) of the thread crea-
         tion is also the context for join().  This means that if
         you intend to return an array from a thread, you must
         use "my ($thread) = threads-"new(...)>, and that if you
         intend to return a scalar, you must use "my $thread =

         If the program exits without all other threads having
         been either joined or detached, then a warning will be
         issued. (A program exits either because one of its
         threads explicitly calls exit(), or in the case of the
         main thread, reaches the end of the main program file.)

         Will make the thread unjoinable, and cause any eventual
         return value to be discarded.

         This will return the thread object for the current

         This will return the id of the thread.  Thread IDs are
         integers, with the main thread in a program being 0.
         Currently Perl assigns a unique tid to every thread ever
         created in your program, assigning the first thread to
         be created a tid of 1, and increasing the tid by 1 for
         each new thread that's created.

         NB the class method "threads->tid()" is a quick way to
         get the current thread id if you don't have your thread
         object handy.

     threads->object( tid )
         This will return the thread object for the thread asso-
         ciated with the specified tid.  Returns undef if there
         is no thread associated with the tid or no tid is speci-
         fied or the specified tid is undef.


perl v5.8.8                2005-02-05                           2

ext::threads::thrPerl(Programmers Refereext::threads::threads(3p)

         This is a suggestion to the OS to let this thread yield
         CPU time to other threads.  What actually happens is
         highly dependent upon the underlying thread implementa-

         You may do "use threads qw(yield)" then use just a bare
         "yield" in your code.

         This will return a list of all non joined, non detached

     async BLOCK;
         "async" creates a thread to execute the block immedi-
         ately following it.  This block is treated as an
         anonymous sub, and so must have a semi-colon after the
         closing brace. Like "threads->new", "async" returns a
         thread object.


     A thread exited while %d other threads were still running
         A thread (not necessarily the main thread) exited while
         there were still other threads running.  Usually it's a
         good idea to first collect the return values of the
         created threads by joining them, and only then exit from
         the main thread.


     The current implementation of threads has been an attempt to
     get a correct threading system working that could be built
     on, and optimized, in newer versions of perl.

     Currently the overhead of creating a thread is rather large,
     also the cost of returning values can be large. These are
     areas were there most likely will be work done to optimize
     what data that needs to be cloned.


     Parent-Child threads.
         On some platforms it might not be possible to destroy
         "parent" threads while there are still existing child

         This will possibly be fixed in later versions of perl.

     tid is I32
         The thread id is a 32 bit integer, it can potentially
         overflow. This might be fixed in a later version of

     Returning objects
         When you return an object the entire stash that the

perl v5.8.8                2005-02-05                           3

ext::threads::thrPerl(Programmers Refereext::threads::threads(3p)

         object is blessed as well.  This will lead to a large
         memory usage.  The ideal situation would be to detect
         the original stash if it existed.

     Creating threads inside BEGIN blocks
         Creating threads inside BEGIN blocks (or during the com-
         pilation phase in general) does not work.  (In Windows,
         trying to use fork() inside BEGIN blocks is an equally
         losing proposition, since it has been implemented in
         very much the same way as threads.)

     PERL_OLD_SIGNALS are not threadsafe, will not be.
         If your Perl has been built with PERL_OLD_SIGNALS (one
         has to explicitly add that symbol to ccflags, see "perl
         -V"), signal handling is not threadsafe.
     Arthur Bergman <sky at nanisky.com>

     threads is released under the same license as Perl.

     Thanks to

     Richard Soderberg <perl at crystalflame.net> Helping me out
     tons, trying to find reasons for races and other weird bugs!

     Simon Cozens <simon at brecon.co.uk> Being there to answer
     zillions of annoying questions

     Rocco Caputo <troc at netrus.net>

     Vipul Ved Prakash <mail at vipul.net> Helping with debug-

     please join perl-ithreads@perl.org for more information


     threads::shared, perlthrtut,
     <http://www.perl.com/pub/a/2002/06/11/threads.html>, perl-
     call, perlembed, perlguts

perl v5.8.8                2005-02-05                           4

Generated on 2022-12-24 01:00:14 by $MirOS: src/scripts/roff2htm,v 1.113 2022/12/21 23:14:31 tg Exp $ — This product includes material provided by mirabilos.

These manual pages and other documentation are copyrighted by their respective writers; their sources are available at the project’s CVSweb, AnonCVS and other mirrors. The rest is Copyright © 2002–2022 MirBSD.

This manual page’s HTML representation is supposed to be valid XHTML/1.1; if not, please send a bug report — diffs preferred.

Kontakt / Impressum & Datenschutzerklärung