 use threads ('yield',
  'stack_size' => 64*4096,
  'exit' => 'threads_only',
  'stringify');
 
  sub start_thread {
  my @args = @_;
  print('Thread started: ', join(' ', @args), "\n");
  }
  my $thr = threads->create('start_thread', 'argument');
  $thr->join();
 
  threads->create(sub { print("I am a thread\n"); })->join();
 
  my $thr2 = async { foreach (@files) { ... } };
  $thr2->join();
  if (my $err = $thr2->error()) {
  warn("Thread error: $err\n");
  }
 
  # Invoke thread in list context (implicit) so it can return a list
  my ($thr) = threads->create(sub { return (qw/a b c/); });
  # or specify list context explicitly
  my $thr = threads->create({'context' => 'list'},
   sub { return (qw/a b c/); });
  my @results = $thr->join();
 
  $thr->detach();
 
  # Get a thread's object
  $thr = threads->self();
  $thr = threads->object($tid);
 
  # Get a thread's ID
  $tid = threads->tid();
  $tid = $thr->tid();
  $tid = "$thr";
 
  # Give other threads a chance to run
  threads->yield();
  yield();
 
  # Lists of non-detached threads
  my @threads = threads->list();
  my $thread_count = threads->list();
 
  my @running = threads->list(threads::running);
  my @joinable = threads->list(threads::joinable);
 
  # Test thread objects
  if ($thr1 == $thr2) {
  ...
  }
 
  # Manage thread stack size
  $stack_size = threads->get_stack_size();
  $old_size = threads->set_stack_size(32*4096);
 
  # Create a thread with a specific context and stack size
  my $thr = threads->create({ 'context' => 'list',
  'stack_size' => 32*4096,
  'exit'   => 'thread_only' },
   \&foo);
 
  # Get thread's context
  my $wantarray = $thr->wantarray();
 
  # Check thread's state
  if ($thr->is_running()) {
  sleep(1);
  }
  if ($thr->is_joinable()) {
  $thr->join();
  }
 
  # Send a signal to a thread
  $thr->kill('SIGUSR1');
 
  # Exit a thread
  threads->exit();

DESCRIPTION

Since Perl 5.8, thread programming has been available using a model calledinterpreter threads which provides a new Perl interpreter for eachthread, and, by default, results in no data or state information being sharedbetween threads.

(Prior to Perl 5.8, 5005threads was available through the Thread.pm API.This threading model has been deprecated, and was removed as of Perl 5.10.0.)

As just mentioned, all variables are, by default, thread local. To use sharedvariables, you need to also load threads::shared:

 use threads;
  use threads::shared;

When loading threads::shared, you must use threads before youuse threads::shared. (threads will emit a warning if you do it theother way around.)

It is strongly recommended that you enable threads via use threads as earlyas possible in your script.

If needed, scripts can be written so as to run on both threaded andnon-threaded Perls:

 my $can_use_threads = eval 'use threads; 1';
  if ($can_use_threads) {
  # Do processing using threads
  ...
  } else {
  # Do it without using threads
  ...
  }

$thr = threads->create(FUNCTION, ARGS)
This will create a new thread that will begin execution with the specifiedentry point function, and give it the ARGS list as parameters. It willreturn the corresponding threads object, or undef if thread creation failed.
FUNCTION may either be the name of a function, an anonymous subroutine, ora code ref.
```
 my $thr = threads->create('func_name', ...);
  # or
  my $thr = threads->create(sub { ... }, ...);
  # or
  my $thr = threads->create(\&func, ...);
 
```
The ->new() method is an alias for ->create().

$thr->join()

This will wait for the corresponding thread to complete its execution. Whenthe thread finishes, ->join() will return the return value(s) of theentry point function.

The context (void, scalar or list) for the return value(s) for ->join()is determined at the time of thread creation.

 # Create thread in list context (implicit)
  my ($thr1) = threads->create(sub {
  my @results = qw(a b c);
  return (@results);
  });
  #   or (explicit)
  my $thr1 = threads->create({'context' => 'list'},
    sub {
  my @results = qw(a b c);
  return (@results);
    });
  # Retrieve list results from thread
  my @res1 = $thr1->join();
 
  # Create thread in scalar context (implicit)
  my $thr2 = threads->create(sub {
  my $result = 42;
  return ($result);
  });
  # Retrieve scalar result from thread
  my $res2 = $thr2->join();
 
  # Create a thread in void context (explicit)
  my $thr3 = threads->create({'void' => 1},
    sub { print("Hello, world\n"); });
  # Join the thread in void context (i.e., no return value)
  $thr3->join();

See THREAD CONTEXT for more details.

If the program exits without all threads having either been joined ordetached, then a warning will be issued.

Calling ->join() or ->detach() on an already joined thread willcause an error to be thrown.

$thr->detach()
Makes the thread unjoinable, and causes any eventual return value to bediscarded. When the program exits, any detached threads that are stillrunning are silently terminated.
If the program exits without all threads having either been joined ordetached, then a warning will be issued.
Calling ->join() or ->detach() on an already detached threadwill cause an error to be thrown.
threads->detach()
Class method that allows a thread to detach itself.
threads->self()
Class method that allows a thread to obtain its own threads object.
$thr->tid()
Returns the ID of the thread. Thread IDs are unique integers with the mainthread in a program being 0, and incrementing by 1 for every thread created.
threads->tid()
Class method that allows a thread to obtain its own ID.
"$thr"
If you add the stringify import option to your use threads declaration,then using a threads object in a string or a string context (e.g., as a hashkey) will cause its ID to be used as the value:
```
 use threads qw(stringify);
 
  my $thr = threads->create(...);
  print("Thread $thr started...\n");  # Prints out: Thread 1 started...
 
```
threads->object($tid)
This will return the threads object for the active thread associatedwith the specified thread ID. If $tid is the value for the current thread,then this call works the same as ->self(). Otherwise, returns undefif there is no thread associated with the TID, if the thread is joined ordetached, if no TID is specified or if the specified TID is undef.
threads->yield()
This is a suggestion to the OS to let this thread yield CPU time to otherthreads. What actually happens is highly dependent upon the underlyingthread implementation.
You may do use threads qw(yield), and then just use yield() in yourcode.
threads->list()
threads->list(threads::all)
threads->list(threads::running)
threads->list(threads::joinable)
With no arguments (or using threads::all) and in a list context, returns alist of all non-joined, non-detached threads objects. In a scalar context,returns a count of the same.
With a true argument (using threads::running), returns a list of allnon-joined, non-detached threads objects that are still running.
With a false argument (using threads::joinable), returns a list of allnon-joined, non-detached threads objects that have finished running (i.e.,for which ->join() will not block).
$thr1->equal($thr2)
Tests if two threads objects are the same thread or not. This is overloadedto the more natural forms:
```
 if ($thr1 == $thr2) {
  print("Threads are the same\n");
  }
  # or
  if ($thr1 != $thr2) {
  print("Threads differ\n");
  }
 
```
(Thread comparison is based on thread IDs.)
async BLOCK;
async creates a thread to execute the block immediately followingit. This block is treated as an anonymous subroutine, and so must have asemicolon after the closing brace. Like threads->create(), asyncreturns a threads object.
$thr->error()
Threads are executed in an eval context. This method will return undefif the thread terminates normally. Otherwise, it returns the value of$@ associated with the thread's execution status in its eval context.
$thr->_handle()
This private method returns the memory location of the internal threadstructure associated with a threads object. For Win32, this is a pointer tothe HANDLE value returned by CreateThread (i.e., HANDLE *); for otherplatforms, it is a pointer to the pthread_t structure used in thepthread_create call (i.e., pthread_t *).
This method is of no use for general Perl threads programming. Its intent isto provide other (XS-based) thread modules with the capability to access, andpossibly manipulate, the underlying thread structure associated with a Perlthread.
threads->_handle()
Class method that allows a thread to obtain its own handle.

EXITING A THREAD

The usual method for terminating a thread is toreturn EXPR from the entry point function with theappropriate return value(s).

threads->exit()
If needed, a thread can be exited at any time by callingthreads->exit(). This will cause the thread to return undef in ascalar context, or the empty list in a list context.
When called from the main thread, this behaves the same as exit(0).
threads->exit(status)
When called from a thread, this behaves like threads->exit() (i.e., theexit status code is ignored).
When called from the main thread, this behaves the same as exit(status).
die()
Calling die() in a thread indicates an abnormal exit for the thread. Any$SIG{__DIE__} handler in the thread will be called first, and then thethread will exit with a warning message that will contain any arguments passedin the die() call.
exit(status)
Calling exit EXPR inside a thread causes the wholeapplication to terminate. Because of this, the use of exit() insidethreaded code, or in modules that might be used in threaded applications, isstrongly discouraged.
If exit() really is needed, then consider using the following:
```
 threads->exit() if threads->can('exit');   # Thread friendly
  exit(status);
 
```
use threads 'exit' => 'threads_only'
This globally overrides the default behavior of calling exit() inside athread, and effectively causes such calls to behave the same asthreads->exit(). In other words, with this setting, calling exit()causes only the thread to terminate.
Because of its global effect, this setting should not be used inside modulesor the like.
The main thread is unaffected by this setting.
threads->create({'exit' => 'thread_only'}, ...)
This overrides the default behavior of exit() inside the newly createdthread only.
$thr->set_thread_exit_only(boolean)
This can be used to change the exit thread only behavior for a thread afterit has been created. With a true argument, exit() will cause only thethread to exit. With a false argument, exit() will terminate theapplication.
The main thread is unaffected by this call.
threads->set_thread_exit_only(boolean)
Class method for use inside a thread to change its own behavior for exit().
The main thread is unaffected by this call.

THREAD STATE

The following boolean methods are useful in determining the state of athread.

$thr->is_running()
Returns true if a thread is still running (i.e., if its entry point functionhas not yet finished or exited).
$thr->is_joinable()
Returns true if the thread has finished running, is not detached and has notyet been joined. In other words, the thread is ready to be joined, and a callto $thr->join() will not block.
$thr->is_detached()
Returns true if the thread has been detached.
threads->is_detached()
Class method that allows a thread to determine whether or not it is detached.

THREAD CONTEXT

As with subroutines, the type of value returned from a thread's entry pointfunction may be determined by the thread's context: list, scalar or void.The thread's context is determined at thread creation. This is necessary sothat the context is available to the entry point function viawantarray. The thread may then specify a value ofthe appropriate type to be returned from ->join().

Explicit context

Because thread creation and thread joining may occur in different contexts, itmay be desirable to state the context explicitly to the thread's entry pointfunction. This may be done by calling ->create() with a hash referenceas the first argument:

 my $thr = threads->create({'context' => 'list'}, \&foo);
  ...
  my @results = $thr->join();

In the above, the threads object is returned to the parent thread in scalarcontext, and the thread's entry point function foo will be called in list(array) context such that the parent thread can receive a list (array) fromthe ->join() call. ('array' is synonymous with 'list'.)

Similarly, if you need the threads object, but your thread will not bereturning a value (i.e., void context), you would do the following:

 my $thr = threads->create({'context' => 'void'}, \&foo);
  ...
  $thr->join();

The context type may also be used as the key in the hash reference followedby a true value:

 threads->create({'scalar' => 1}, \&foo);
  ...
  my ($thr) = threads->list();
  my $result = $thr->join();

Implicit context

If not explicitly stated, the thread's context is implied from the contextof the ->create() call:

 # Create thread in list context
  my ($thr) = threads->create(...);
 
  # Create thread in scalar context
  my $thr = threads->create(...);
 
  # Create thread in void context
  threads->create(...);

$thr->wantarray()

This returns the thread's context in the same manner aswantarray.

threads->wantarray()

Class method to return the current thread's context. This returns the samevalue as running wantarray inside the currentthread's entry point function.

THREAD STACK SIZE

The default per-thread stack size for different platforms variessignificantly, and is almost always far more than is needed for mostapplications. On Win32, Perl's makefile explicitly sets the default stack to16 MB; on most other platforms, the system default is used, which again may bemuch larger than is needed.

By tuning the stack size to more accurately reflect your application's needs,you may significantly reduce your application's memory usage, and increase thenumber of simultaneously running threads.

Note that on Windows, address space allocation granularity is 64 KB,therefore, setting the stack smaller than that on Win32 Perl will not save anymore memory.

threads->get_stack_size();
Returns the current default per-thread stack size. The default is zero, whichmeans the system default stack size is currently in use.
$size = $thr->get_stack_size();
Returns the stack size for a particular thread. A return value of zeroindicates the system default stack size was used for the thread.
$old_size = threads->set_stack_size($new_size);
Sets a new default per-thread stack size, and returns the previous setting.
Some platforms have a minimum thread stack size. Trying to set the stack sizebelow this value will result in a warning, and the minimum stack size will beused.
Some Linux platforms have a maximum stack size. Setting too large of a stacksize will cause thread creation to fail.
If needed, $new_size will be rounded up to the next multiple of the memorypage size (usually 4096 or 8192).
Threads created after the stack size is set will then either callpthread_attr_setstacksize() (for pthreads platforms), or supply thestack size to CreateThread() (for Win32 Perl).
(Obviously, this call does not affect any currently extant threads.)
use threads ('stack_size' => VALUE);
This sets the default per-thread stack size at the start of the application.
$ENV{'PERL5_ITHREADS_STACK_SIZE'}
The default per-thread stack size may be set at the start of the applicationthrough the use of the environment variable PERL5_ITHREADS_STACK_SIZE:
```
 PERL5_ITHREADS_STACK_SIZE=1048576
  export PERL5_ITHREADS_STACK_SIZE
  perl -e'use threads; print(threads->get_stack_size(), "\n")'
 
```
This value overrides any stack_size parameter given to use threads. Itsprimary purpose is to permit setting the per-thread stack size for legacythreaded applications.
threads->create({'stack_size' => VALUE}, FUNCTION, ARGS)
To specify a particular stack size for any individual thread, call->create() with a hash reference as the first argument:
```
 my $thr = threads->create({'stack_size' => 32*4096}, \&foo, @args);
 
```
$thr2 = $thr1->create(FUNCTION, ARGS)
This creates a new thread ($thr2) that inherits the stack size from anexisting thread ($thr1). This is shorthand for the following:
```
 my $stack_size = $thr1->get_stack_size();
  my $thr2 = threads->create({'stack_size' => $stack_size}, FUNCTION, ARGS);
 
```

THREAD SIGNALLING

When safe signals is in effect (the default behavior - see Unsafe signalsfor more details), then signals may be sent and acted upon by individualthreads.

$thr->kill('SIG...');
Sends the specified signal to the thread. Signal names and (positive) signalnumbers are the same as those supported bykill SIGNAL, LIST. For example, 'SIGTERM', 'TERM' and(depending on the OS) 15 are all valid arguments to ->kill().
Returns the thread object to allow for method chaining:
```
 $thr->kill('SIG...')->join();
 
```

Signal handlers need to be set up in the threads for the signals they areexpected to act upon. Here's an example for cancelling a thread:

 use threads;
 
  sub thr_func
  {
  # Thread 'cancellation' signal handler
  $SIG{'KILL'} = sub { threads->exit(); };
 
  ...
  }
 
  # Create a thread
  my $thr = threads->create('thr_func');
 
  ...
 
  # Signal the thread to terminate, and then detach
  # it so that it will get cleaned up automatically
  $thr->kill('KILL')->detach();

Here's another simplistic example that illustrates the use of threadsignalling in conjunction with a semaphore to provide rudimentary suspendand resume capabilities:

 use threads;
  use Thread::Semaphore;
 
  sub thr_func
  {
  my $sema = shift;
 
  # Thread 'suspend/resume' signal handler
  $SIG{'STOP'} = sub {
  $sema->down();  # Thread suspended
  $sema->up(); # Thread resumes
  };
 
  ...
  }
 
  # Create a semaphore and pass it to a thread
  my $sema = Thread::Semaphore->new();
  my $thr = threads->create('thr_func', $sema);
 
  # Suspend the thread
  $sema->down();
  $thr->kill('STOP');
 
  ...
 
  # Allow the thread to continue
  $sema->up();

CAVEAT: The thread signalling capability provided by this module does notactually send signals via the OS. It emulates signals at the Perl-levelsuch that signal handlers are called in the appropriate thread. For example,sending $thr->kill('STOP') does not actually suspend a thread (or thewhole process), but does cause a $SIG{'STOP'} handler to be called in thatthread (as illustrated above).

As such, signals that would normally not be appropriate to use in thekill() command (e.g., kill('KILL', $$)) are okay to use with the->kill() method (again, as illustrated above).

Correspondingly, sending a signal to a thread does not disrupt the operationthe thread is currently working on: The signal will be acted upon after thecurrent operation has completed. For instance, if the thread is stuck onan I/O call, sending it a signal will not cause the I/O call to be interruptedsuch that the signal is acted up immediately.

Sending a signal to a terminated thread is ignored.

WARNINGS

Perl exited with active threads:
If the program exits without all threads having either been joined ordetached, then this warning will be issued.
NOTE: If the main thread exits, then this warning cannot be suppressedusing no warnings 'threads'; as suggested below.
Thread creation failed: pthread_create returned #
See the appropriate man page for pthread_create to determine the actualcause for the failure.
Thread # terminated abnormally: ...
A thread terminated in some manner other than just returning from its entrypoint function, or by using threads->exit(). For example, the threadmay have terminated because of an error, or by using die.
Using minimum thread stack size of #
Some platforms have a minimum thread stack size. Trying to set the stack sizebelow this value will result in the above warning, and the stack size will beset to the minimum.
Thread creation failed: pthread_attr_setstacksize(SIZE) returned 22
The specified SIZE exceeds the system's maximum stack size. Use a smallervalue for the stack size.

If needed, thread warnings can be suppressed by using:

 no warnings 'threads';

in the appropriate scope.

ERRORS

This Perl not built to support threads
The particular copy of Perl that you're trying to use was not built using theuseithreads configuration option.
Having threads support requires all of Perl and all of the XS modules in thePerl installation to be rebuilt; it is not just a question of adding thethreads module (i.e., threaded and non-threaded Perls are binaryincompatible.)
Cannot change stack size of an existing thread
The stack size of currently extant threads cannot be changed, therefore, thefollowing results in the above error:
```
 $thr->set_stack_size($size);
 
```
Cannot signal threads without safe signals
Safe signals must be in effect to use the ->kill() signalling method.See Unsafe signals for more details.
Unrecognized signal name: ...
The particular copy of Perl that you're trying to use does not support thespecified signal being used in a ->kill() call.

BUGS AND LIMITATIONS

Before you consider posting a bug report, please consult, and possibly post amessage to the discussion forum to see if what you've encountered is a knownproblem.

Thread-safe modules
See Making your module threadsafe in perlmod when creating modules that maybe used in threaded applications, especially if those modules use non-Perldata, or XS code.
Using non-thread-safe modules
Unfortunately, you may encounter Perl modules that are not thread-safe.For example, they may crash the Perl interpreter during execution, or may dumpcore on termination. Depending on the module and the requirements of yourapplication, it may be possible to work around such difficulties.
If the module will only be used inside a thread, you can try loading themodule from inside the thread entry point function using require (andimport if needed):
```
 sub thr_func
  {
  require Unsafe::Module
  # Unsafe::Module->import(...);
 
  ....
  }
 
```
If the module is needed inside the main thread, try modifying yourapplication so that the module is loaded (again using require and->import()) after any threads are started, and in such a way that noother threads are started afterwards.
If the above does not work, or is not adequate for your application, then filea bug report on http://rt.cpan.org/Public/ against the problematic module.
Memory consumption
On most systems, frequent and continual creation and destruction of threadscan lead to ever-increasing growth in the memory footprint of the Perlinterpreter. While it is simple to just launch threads and then->join() or ->detach() them, for long-lived applications, it isbetter to maintain a pool of threads, and to reuse them for the work needed,using queues to notify threads of pending work. The CPANdistribution of this module contains a simple example(examples/pool_reuse.pl) illustrating the creation, use and monitoring of apool of reusable threads.
Current working directory
On all platforms except MSWin32, the setting for the current working directoryis shared among all threads such that changing it in one thread (e.g., usingchdir()) will affect all the threads in the application.
On MSWin32, each thread maintains its own the current working directorysetting.
Environment variables
Currently, on all platforms except MSWin32, all system calls (e.g., usingsystem() or back-ticks) made from threads use the environment variablesettings from the main thread. In other words, changes made to %ENV ina thread will not be visible in system calls made by that thread.
To work around this, set environment variables as part of the system call.For example:
```
 my $msg = 'hello';
  system("FOO=$msg; echo \$FOO");   # Outputs 'hello' to STDOUT
 
```
On MSWin32, each thread maintains its own set of environment variables.

Catching signals

Signals are caught by the main thread (thread ID = 0) of a script.Therefore, setting up signal handlers in threads for purposes other thanTHREAD SIGNALLING as documented above will not accomplish what isintended.

This is especially true if trying to catch SIGALRM in a thread. To handlealarms in threads, set up a signal handler in the main thread, and then useTHREAD SIGNALLING to relay the signal to the thread:

  # Create thread with a task that may time out
   my $thr->create(sub {
   threads->yield();
   eval {
   $SIG{ALRM} = sub { die("Timeout\n"); };
   alarm(10);
   ...  # Do work here
   alarm(0);
   };
   if ($@ =~ /Timeout/) {
   warn("Task in thread timed out\n");
   }
   };
 
   # Set signal handler to relay SIGALRM to thread
   $SIG{ALRM} = sub { $thr->kill('ALRM') };
 
   ... # Main thread continues working

Parent-child threads
On some platforms, it might not be possible to destroy parent threads whilethere are still existing child threads.
Creating threads inside special blocks
Creating threads inside BEGIN, CHECK or INIT blocks should not berelied upon. Depending on the Perl version and the application code, resultsmay range from success, to (apparently harmless) warnings of leaked scalar, orall the way up to crashing of the Perl interpreter.
Unsafe signals
Since Perl 5.8.0, signals have been made safer in Perl by postponing theirhandling until the interpreter is in a safe state. SeeSafe Signals in perl58delta and Deferred Signals (Safe Signals) in perlipcfor more details.
Safe signals is the default behavior, and the old, immediate, unsafesignalling behavior is only in effect in the following situations:
- Perl has been built with PERL_OLD_SIGNALS (see perl -V).
- The environment variable PERL_SIGNALS is set to unsafe (see PERL_SIGNALS in perlrun).
- The module Perl::Unsafe::Signals is used.
If unsafe signals is in effect, then signal handling is not thread-safe, andthe ->kill() signalling method cannot be used.
Returning closures from threads
Returning closures from threads should not be relied upon. Depending of thePerl version and the application code, results may range from success, to(apparently harmless) warnings of leaked scalar, or all the way up to crashingof the Perl interpreter.
Returning objects from threads
Returning objects from threads does not work. Depending on the classesinvolved, you may be able to work around this by returning a serializedversion of the object (e.g., using Data::Dumper or Storable), and thenreconstituting it in the joining thread. If you're using Perl 5.10.0 orlater, and if the class supports shared objects,you can pass them via shared queues.
END blocks in threads
It is possible to add END blocks to threads by using require VERSION oreval EXPR with the appropriate code. These END blockswill then be executed when the thread's interpreter is destroyed (i.e., eitherduring a ->join() call, or at program termination).
However, calling any threads methods in such an END block will mostlikely fail (e.g., the application may hang, or generate an error) due tomutexes that are needed to control functionality within the threads module.
For this reason, the use of END blocks in threads is stronglydiscouraged.
Open directory handles
In perl 5.14 and higher, on systems other than Windows that donot support the fchdir C function, directory handles (seeopendir DIRHANDLE,EXPR) will not be copied to newthreads. You can use the d_fchdir variable in Config.pm todetermine whether your system supports it.
In prior perl versions, spawning threads with open directory handles wouldcrash the interpreter.[perl #75154]
Perl Bugs and the CPAN Version of threads
Support for threads extends beyond the code in this module (i.e.,threads.pm and threads.xs), and into the Perl interpreter itself. Olderversions of Perl contain bugs that may manifest themselves despite using thelatest version of threads from CPAN. There is no workaround for this otherthan upgrading to the latest version of Perl.
Even with the latest version of Perl, it is known that certain constructswith threads may result in warning messages concerning leaked scalars orunreferenced scalars. However, such warnings are harmless, and may safely beignored.
You can search for threads related bug reports athttp://rt.cpan.org/Public/. If needed submit any new bugs, problems,patches, etc. to: http://rt.cpan.org/Public/Dist/Display.html?Name=threads

REQUIREMENTS

Perl 5.8.0 or later

AUTHOR

Artur Bergman <sky AT crucially DOT net>

CPAN version produced by Jerry D. Hedden <jdhedden AT cpan DOT org>

LICENSE

threads is released under the same license as Perl.

ACKNOWLEDGEMENTS

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

Simon Cozens <simon AT brecon DOT co DOT uk> -Being there to answer zillions of annoying questions

Rocco Caputo <troc AT netrus DOT net>

Vipul Ved Prakash <mail AT vipul DOT net> -Helping with debugging

Dean Arnold <darnold AT presicient DOT com> -Stack size API

Source : perldoc.perl.org - Official documentation for the Perl programming language
Site maintained by Jon Allen (JJ) See the project page for more details
Documentation maintained by the Perl 5 Porters

(Sebelumnya) Perl pragma to predeclare sub names

Perl extension for sharing dat ... (Berikutnya)