forks - drop-in replacement for Perl threads using fork()
use forks; my $thread = threads->new( sub { # or ->create or async() print "Hello world from a thread\n"; } ); $thread->join; threads->detach; $thread->detach; my $tid = $thread->tid; my $owntid = threads->tid; my $self = threads->self; my $threadx = threads->object( $tidx ); threads->yield(); $_->join foreach threads->list; unless (fork) { threads->isthread; # intended to be used in a child-init Apache handler } use forks qw(debug); threads->debug( 1 ); # use forks as a drop-in replacement for an ithreads application perl -Mforks -Mforks::shared threadapplication # support fractional and use hi-res time for cond_timedwait events perl -MTime::HiRes -Mforks -Mforks::shared threadapplication
The "forks" pragma allows a developer to use threads without having to have a threaded perl, or to even run 5.8.0 or higher. There were a number of goals that I am trying to reach with this implementation.
Using this module only makes sense if you run on a system that has an implementation of the fork function by the Operating System. Windows is currently the only known system on which Perl runs which does not have an implementation of fork. Therefore, it doesn't make any sense to use this module on a Windows system. And therefore, a check is made during installation barring you from installing on a Windows system.
fork
The standard Perl 5.8.0 threads implementation is very memory consuming, which makes it basically impossible to use in a production environment, particularly with mod_perl and Apache. Because of the use of the standard Unix fork() capabilities, most operating systems will be able to use the Copy-On-Write (COW) memory sharing capabilities (whereas with the standard Perl 5.8.0 threads implementation, this is thwarted by the Perl interpreter cloning process that is used to create threads). The memory savings have been confirmed.
This threads implementation allows you to use a standard, pre-forking Apache server and have the children act as threads (with the class method "isthread"). This is as yet untested within Apache, but should work.
You should be able to run threaded applications unchanged by simply making sure that the "forks" and "forks::shared" modules are loaded, e.g. by specifying them on the command line.
Because you do not need a threaded Perl to use forks.pm, you can start prototyping threaded applications with the Perl executable that you are used to. Just download and install the "forks" package from CPAN. So the threshold for trying out threads in Perl has become much lower. Even Perl 5.005 should, in principle, be able to support the forks.pm module; however, some issues with regards to the availability of XS features between different versions of Perl, it seems that 5.6.0 (unthreaded) is what you need at least.
This package has successfully been proven as stable and reliable in production environments. I have personally used it in high-availability, database-driven, financial message processing server applications for more than two years now with great success. Also, unlike pure ithreads, forks.pm is fully compatible with all perl modules, whether or not they have been updated to be ithread safe. This means that you do not need to feel limited in what you can develop as a threaded perl application, a problem that continues to plague the acceptance of ithreads in production enviroments today. Just handle these modules as you would when using a standard fork: be sure to create new instances of, or connections to, resources where a single instance can not be shared between multiple processes.
The only major concern is the potentially slow (relative to pure ithreads) performance of shared data and locks. If your application doesn't depend on extensive semaphore use, and reads/writes from shared variables moderately (such as using them primarily to deliver data to a child thread to process and the child thread uses a shared structure to return the result), then this will likely not be an issue for your application. See the TODO section regarding plans to tackle this issue.
Also, you may wish to try <forks::BerkeleyDB>, which has shown signifigant performance gains and consistent throughoutput in high-concurrency shared variable applications.
Devel::Required (any) IO::Socket (1.18) reaper (0.03) Scalar::Util (1.01) Storable (any)
This version is mostly written in Perl. Inter-process communication is done by using sockets, with the process that stores the shared variables as the server and all the processes that function as threads, as clients.
The reason I chose sockets for inter-thread communication above using a shared memory library, is that a blocking socket allows you to elegantly solve the problem of a thread that is blocking for a certain event. Any polling that might occur, is not occurring at the Perl level, but at the level of the socket, which should be much better and probably very optimized already.
Apart from the standard class methods, the following class methods are supplied by the "forks" threads implementation.
unless (fork) { threads->isthread; # this process is a detached thread now exit; # can not return values, as thread is detached }
The isthread class method attempt to make a connection with the shared variables process. If it succeeds, then the process will function as a detached thread and will allow all the threads methods to operate.
isthread
This method is mainly intended to be used from within a child-init handler in a pre-forking Apache server. All the children that handle requests become threads as far as Perl is concerned, allowing you to use shared variables between all of the Apache processes.
threads->debug( 1 ); $debug = threads->debug;
The "debug" class method allows you to (re)set a flag which causes extensive debugging output of the communication between threads to be output to STDERR. The format is still subject to change and therefore still undocumented.
Debugging can only be switched on by defining the environment variable THREADS_DEBUG. If the environment variable does not exist when the forks.pm module is compiled, then all debugging code will be optimised away to create a better performance. If the environment variable has a true value, then debugging will also be enabled from the start.
THREADS_DEBUG
For security, inter-thread communication INET sockets only will allow connections from the default local machine IPv4 loopback address (e.g 127.0.0.1). However, this filter may be modified by defining the environment variable THREADS_IP_MASK with a standard perl regular expression (or with no value, which would disable the filter).
THREADS_IP_MASK
For users who do not wish to (or can not) use TCP sockets, UNIX socket support is available. This can be only switched on by defining the environment variable THREADS_SOCKET_UNIX. If the environment variable has a true value, then UNIX sockets will be used instead of the default TCP sockets. Socket descriptors are currently written to /var/tmp and given a+rw access by default (for cleanest functional support on multi-user systems).
THREADS_SOCKET_UNIX
This feature is excellent for applications that require extra security, as it does not expose forks.pm to any INET vunerabilities your system may be subject to (i.e. systems not protected by a firewall). It also may provide an additional performance boost, as there is less system overhead necessary to handle UNIX vs INET socket communication.
Some caveats that you need to be aware of.
Because of the use of sockets for inter-thread communication, there is an inherent larger latency with the interaction between threads. However, the fact that TCP sockets are used, may open up the possibility to share threads over more than one physical machine.
You may decrease some latencyby using UNIX sockets (see "UNIX socket support").
Also, you may wish to try <forks::BerkeleyDB>, which has shown signifigant performance gains and consistent throughoutput in applications requiring high-concurrency shared variable access.
In order to be compatible with perl's core system() function on all platforms, extra care has gone into implementing a smarter $SIG{CHLD} in forks.pm. If any modules you use modify $SIG{CHLD} (or if you attempt to modify it yourself), you may end up with undesired issues such as unreaped processes or a system() function that returns -1 instead of the correct exit value. See perlipc for more information regarding common issues with modifying $SIG{CHLD}.
If $SIG{CHLD} has to be modified in any way by your software, please take extra care to implement a handler that follows the requirements of chained signal handlers. See reaper for more information.
You may define the environment variable THREADS_SIGCHLD_IGNORE to to force forks to use 'IGNORE' on systems where a custom CHLD signal handler has been automatically installed to support correct exit code of perl core system() function. There should be no need to use this unless you encounter specific issues with reaper signal chaining.
To get forks.pm working on Perl 5.6.x, it was necessary to use a source filter to ensure a smooth upgrade path from using forks under Perl 5.6.x to Perl 5.8.x and higher. The source filter used is pretty simple and may prove to be too simple. Please report any problems that you may find when running under 5.6.x.
See the TODO file in the distribution.
These problems are known and will hopefully be fixed in the future:
In the standard Perl ithreads implementation, you can signal a variable without having to lock() it. This causes a (suppressable) warning. Due to implementation details, probably having to do with communication getting out of sync between server and client thread, forks.pm needs to die when this happens. Patches are welcome.
Although there are no errors in the test-suite, the test harness sometimes thinks there is something wrong because of an unexpected exit() value. This is an issue with Test::More's END block, which wasn't designed to co-exist with a threads environment and forked processes. Hopefully, that module will be patched in the future, but for now, the warnings are harmless and may be safely ignored.
In the standard Perl threads implementation, arrays and hashes are re-initialized when they become shared (with the share()) function. The share() function of forks::shared does not initialize arrays and hashes when they become shared with the share() function.
This could be considered a bug in the standard Perl implementation. In any case this is an inconsistency of the behaviour of threads.pm and forks.pm. Maybe a special "totheletter" option should be added to forks.pm to make forks.pm follow this behaviour of threads.pm to the letter.
And of course, there might be other, undiscovered issues. Patches are welcome!
All the people reporting problems and fixes. More specifically in alphabetical order:
For finding that a child thread could not wake the very first parent thread with cond_signal, and providing a patch to fix it.
For implementing the first working version of Perl threads support and providing us with an API to build on.
For helping me through the initial birthing pains.
For spotting a problem with very large shared scalar values.
For making sure everything runs with warnings enabled.
For pointing me to the source filter solution for Perl 5.6.x.
Eric Rybski <rybskej@yahoo.com>.
Elizabeth Mattijsen, <liz@dijkmat.nl>.
Copyright (c) 2005-2006 Eric Rybski <rybskej@yahoo.com>, 2002-2004 Elizabeth Mattijsen <liz@dijkmat.nl>. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
threads, forks::BerkeleyDB.
To install forks, copy and paste the appropriate command in to your terminal.
cpanm
cpanm forks
CPAN shell
perl -MCPAN -e shell install forks
For more information on module installation, please visit the detailed CPAN module installation guide.