=head1 NAME
perlthrtut - Tutorial on threads in Perl
=head1 DESCRIPTION
This tutorial describes the use of Perl interpreter threads (sometimes
referred to as I) that was first introduced in Perl 5.6.0. In this
model, each thread runs in its own Perl interpreter, and any data sharing
between threads must be explicit. The user-level interface for I
uses the L class.
B: There was another older Perl threading flavor called the 5.005 model
that used the L class. This old model was known to have problems, is
deprecated, and was removed for release 5.10. You are
strongly encouraged to migrate any existing 5.005 threads code to the new
model as soon as possible.
You can see which (or neither) threading flavour you have by
running C and looking at the C section.
If you have C you have ithreads, if you
have C you have 5.005 threads.
If you have neither, you don't have any thread support built in.
If you have both, you are in trouble.
The L and L modules are included in the core Perl
distribution. Additionally, they are maintained as a separate modules on
CPAN, so you can check there for any updates.
=head1 What Is A Thread Anyway?
A thread is a flow of control through a program with a single
execution point.
Sounds an awful lot like a process, doesn't it? Well, it should.
Threads are one of the pieces of a process. Every process has at least
one thread and, up until now, every process running Perl had only one
thread. With 5.8, though, you can create extra threads. We're going
to show you how, when, and why.
=head1 Threaded Program Models
There are three basic ways that you can structure a threaded
program. Which model you choose depends on what you need your program
to do. For many non-trivial threaded programs, you'll need to choose
different models for different pieces of your program.
=head2 Boss/Worker
The boss/worker model usually has one I thread and one or more
I threads. The boss thread gathers or generates tasks that need
to be done, then parcels those tasks out to the appropriate worker
thread.
This model is common in GUI and server programs, where a main thread
waits for some event and then passes that event to the appropriate
worker threads for processing. Once the event has been passed on, the
boss thread goes back to waiting for another event.
The boss thread does relatively little work. While tasks aren't
necessarily performed faster than with any other method, it tends to
have the best user-response times.
=head2 Work Crew
In the work crew model, several threads are created that do
essentially the same thing to different pieces of data. It closely
mirrors classical parallel processing and vector processors, where a
large array of processors do the exact same thing to many pieces of
data.
This model is particularly useful if the system running the program
will distribute multiple threads across different processors. It can
also be useful in ray tracing or rendering engines, where the
individual threads can pass on interim results to give the user visual
feedback.
=head2 Pipeline
The pipeline model divides up a task into a series of steps, and
passes the results of one step on to the thread processing the
next. Each thread does one thing to each piece of data and passes the
results to the next thread in line.
This model makes the most sense if you have multiple processors so two
or more threads will be executing in parallel, though it can often
make sense in other contexts as well. It tends to keep the individual
tasks small and simple, as well as allowing some parts of the pipeline
to block (on I/O or system calls, for example) while other parts keep
going. If you're running different parts of the pipeline on different
processors you may also take advantage of the caches on each
processor.
This model is also handy for a form of recursive programming where,
rather than having a subroutine call itself, it instead creates
another thread. Prime and Fibonacci generators both map well to this
form of the pipeline model. (A version of a prime number generator is
presented later on.)
=head1 What kind of threads are Perl threads?
If you have experience with other thread implementations, you might
find that things aren't quite what you expect. It's very important to
remember when dealing with Perl threads that I for all values of X. They aren't POSIX threads, or
DecThreads, or Java's Green threads, or Win32 threads. There are
similarities, and the broad concepts are the same, but if you start
looking for implementation details you're going to be either
disappointed or confused. Possibly both.
This is not to say that Perl threads are completely different from
everything that's ever come before -- they're not. Perl's threading
model owes a lot to other thread models, especially POSIX. Just as
Perl is not C, though, Perl threads are not POSIX threads. So if you
find yourself looking for mutexes, or thread priorities, it's time to
step back a bit and think about what you want to do and how Perl can
do it.
However, it is important to remember that Perl threads cannot magically
do things unless your operating system's threads allow it. So if your
system blocks the entire process on C, Perl usually will, as well.
B
=head1 Thread-Safe Modules
The addition of threads has changed Perl's internals
substantially. There are implications for people who write
modules with XS code or external libraries. However, since Perl data is
not shared among threads by default, Perl modules stand a high chance of
being thread-safe or can be made thread-safe easily. Modules that are not
tagged as thread-safe should be tested or code reviewed before being used
in production code.
Not all modules that you might use are thread-safe, and you should
always assume a module is unsafe unless the documentation says
otherwise. This includes modules that are distributed as part of the
core. Threads are a relatively new feature, and even some of the standard
modules aren't thread-safe.
Even if a module is thread-safe, it doesn't mean that the module is optimized
to work well with threads. A module could possibly be rewritten to utilize
the new features in threaded Perl to increase performance in a threaded
environment.
If you're using a module that's not thread-safe for some reason, you
can protect yourself by using it from one, and only one thread at all.
If you need multiple threads to access such a module, you can use semaphores and
lots of programming discipline to control access to it. Semaphores
are covered in L.
See also L.
=head1 Thread Basics
The L module provides the basic functions you need to write
threaded programs. In the following sections, we'll cover the basics,
showing you what you need to do to create a threaded program. After
that, we'll go over some of the features of the L module that
make threaded programming easier.
=head2 Basic Thread Support
Thread support is a Perl compile-time option -- it's something that's
turned on or off when Perl is built at your site, rather than when
your programs are compiled. If your Perl wasn't compiled with thread
support enabled, then any attempt to use threads will fail.
Your programs can use the Config module to check whether threads are
enabled. If your program can't run without them, you can say something
like:
use Config;
$Config{useithreads} or die('Recompile Perl with threads to run this program.');
A possibly-threaded program using a possibly-threaded module might
have code like this:
use Config;
use MyMod;
BEGIN {
if ($Config{useithreads}) {
# We have threads
require MyMod_threaded;
import MyMod_threaded;
} else {
require MyMod_unthreaded;
import MyMod_unthreaded;
}
}
Since code that runs both with and without threads is usually pretty
messy, it's best to isolate the thread-specific code in its own
module. In our example above, that's what C is, and it's
only imported if we're running on a threaded Perl.
=head2 A Note about the Examples
In a real situation, care should be taken that all threads are finished
executing before the program exits. That care has B been taken in these
examples in the interest of simplicity. Running these examples I will
produce error messages, usually caused by the fact that there are still
threads running when the program exits. You should not be alarmed by this.
=head2 Creating Threads
The L module provides the tools you need to create new
threads. Like any other module, you need to tell Perl that you want to use
it; C