perlothrtut.1

来自「视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.」· 1 代码 · 共 1,197 行 · 第 1/4 页

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.
.PP
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 \s-1POSIX\s0.  Just as
Perl is not C, though, Perl threads are not \s-1POSIX\s0 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.
.SH "Threadsafe Modules"
.IX Header "Threadsafe Modules"
The addition of threads has changed Perl's internals
substantially.  There are implications for people who write
modules\*(--especially modules with \s-1XS\s0 code or external libraries.  While
most modules won't encounter any problems, modules that aren't
explicitly tagged as thread-safe should be tested before being used in
production code.
.PP
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 beta feature, and even some of the standard
modules aren't thread-safe.
.PP
If you're using a module that's not thread-safe for some reason, you
can protect yourself by using semaphores and lots of programming
discipline to control access to the module.  Semaphores are covered
later in the article.  Perl Threads Are Different
.SH "Thread Basics"
.IX Header "Thread Basics"
The core Thread 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 Thread module that
make threaded programming easier.
.Sh "Basic Thread Support"
.IX Subsection "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.
.PP
Remember that the threading support in 5.005 is in beta release, and
should be treated as such.   You should expect that it may not function
entirely properly, and the thread interface may well change some
before it is a fully supported, production release.  The beta version
shouldn't be used for mission-critical projects.  Having said that,
threaded Perl is pretty nifty, and worth a look.
.PP
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:
.PP
.Vb 1
\&  $Config{usethreads} or die "Recompile Perl with threads to run this program.";
.Ve
.PP
A possibly-threaded program using a possibly-threaded module might
have code like this:
.PP
.Vb 2
\&    use Config; 
\&    use MyMod; 
\&
\&    if ($Config{usethreads}) { 
\&        # We have threads 
\&        require MyMod_threaded; 
\&        import MyMod_threaded; 
\&    } else { 
\&        require MyMod_unthreaded; 
\&        import MyMod_unthreaded; 
\&    }
.Ve
.PP
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 MyMod_threaded is, and it's
only imported if we're running on a threaded Perl.
.Sh "Creating Threads"
.IX Subsection "Creating Threads"
The Thread package provides the tools you need to create new
threads.  Like any other module, you need to tell Perl you want to use
it; use Thread imports all the pieces you need to create basic
threads.
.PP
The simplest, straightforward way to create a thread is with \fInew()\fR:
.PP
.Vb 1
\&    use Thread; 
\&
\&    $thr = Thread\->new( \e&sub1 );
\&
\&    sub sub1 { 
\&        print "In the thread\en"; 
\&    }
.Ve
.PP
The \fInew()\fR method takes a reference to a subroutine and creates a new
thread, which starts executing in the referenced subroutine.  Control
then passes both to the subroutine and the caller.
.PP
If you need to, your program can pass parameters to the subroutine as
part of the thread startup.  Just include the list of parameters as
part of the \f(CW\*(C`Thread::new\*(C'\fR call, like this:
.PP
.Vb 5
\&    use Thread; 
\&    $Param3 = "foo"; 
\&    $thr = Thread\->new( \e&sub1, "Param 1", "Param 2", $Param3 );
\&    $thr = Thread\->new( \e&sub1, @ParamList );
\&    $thr = Thread\->new( \e&sub1, qw(Param1 Param2 $Param3) );
\&
\&    sub sub1 { 
\&        my @InboundParameters = @_; 
\&        print "In the thread\en"; 
\&        print "got parameters >", join("<>", @InboundParameters), "<\en"; 
\&    }
.Ve
.PP
The subroutine runs like a normal Perl subroutine, and the call to new
Thread returns whatever the subroutine returns.
.PP
The last example illustrates another feature of threads.  You can spawn
off several threads using the same subroutine.  Each thread executes
the same subroutine, but in a separate thread with a separate
environment and potentially separate arguments.
.PP
The other way to spawn a new thread is with \fIasync()\fR, which is a way to
spin off a chunk of code like \fIeval()\fR, but into its own thread:
.PP
.Vb 1
\&    use Thread qw(async);
\&
\&    $LineCount = 0; 
\&
\&    $thr = async { 
\&        while(<>) {$LineCount++}         
\&        print "Got $LineCount lines\en";
\&    }; 
\&
\&    print "Waiting for the linecount to end\en"; 
\&    $thr\->join; 
\&    print "All done\en";
.Ve
.PP
You'll notice we did a use Thread qw(async) in that example.  async is
not exported by default, so if you want it, you'll either need to
import it before you use it or fully qualify it as
Thread::async.  You'll also note that there's a semicolon after the
closing brace.  That's because \fIasync()\fR treats the following block as an
anonymous subroutine, so the semicolon is necessary.
.PP
Like \fIeval()\fR, the code executes in the same context as it would if it
weren't spun off.  Since both the code inside and after the async start
executing, you need to be careful with any shared resources.  Locking
and other synchronization techniques are covered later.
.Sh "Giving up control"
.IX Subsection "Giving up control"
There are times when you may find it useful to have a thread
explicitly give up the \s-1CPU\s0 to another thread.  Your threading package
might not support preemptive multitasking for threads, for example, or
you may be doing something compute-intensive and want to make sure
that the user-interface thread gets called frequently.  Regardless,
there are times that you might want a thread to give up the processor.
.PP
Perl's threading package provides the \fIyield()\fR function that does
this. \fIyield()\fR is pretty straightforward, and works like this:
.PP
.Vb 10
\&    use Thread qw(yield async); 
\&    async { 
\&        my $foo = 50; 
\&        while ($foo\-\-) { print "first async\en" }
\&        yield; 
\&        $foo = 50; 
\&        while ($foo\-\-) { print "first async\en" } 
\&    }; 
\&    async { 
\&        my $foo = 50; 
\&        while ($foo\-\-) { print "second async\en" }
\&        yield; 
\&        $foo = 50; 
\&        while ($foo\-\-) { print "second async\en" } 
\&    };
.Ve
.Sh "Waiting For A Thread To Exit"
.IX Subsection "Waiting For A Thread To Exit"
Since threads are also subroutines, they can return values.  To wait
for a thread to exit and extract any scalars it might return, you can
use the \fIjoin()\fR method.
.PP
.Vb 2
\&    use Thread; 
\&    $thr = Thread\->new( \e&sub1 );
\&
\&    @ReturnData = $thr\->join; 
\&    print "Thread returned @ReturnData"; 
\&
\&    sub sub1 { return "Fifty\-six", "foo", 2; }
.Ve
.PP
In the example above, the \fIjoin()\fR method returns as soon as the thread
ends.  In addition to waiting for a thread to finish and gathering up
any values that the thread might have returned, \fIjoin()\fR also performs
any \s-1OS\s0 cleanup necessary for the thread.  That cleanup might be
important, especially for long-running programs that spawn lots of
threads.  If you don't want the return values and don't want to wait
for the thread to finish, you should call the \fIdetach()\fR method
instead. \fIdetach()\fR is covered later in the article.
.Sh "Errors In Threads"
.IX Subsection "Errors In Threads"
So what happens when an error occurs in a thread? Any errors that
could be caught with \fIeval()\fR are postponed until the thread is
joined.  If your program never joins, the errors appear when your
program exits.
.PP
Errors deferred until a \fIjoin()\fR can be caught with \fIeval()\fR:
.PP
.Vb 8
\&    use Thread qw(async); 
\&    $thr = async {$b = 3/0};   # Divide by zero error
\&    $foo = eval {$thr\->join}; 
\&    if ($@) { 
\&        print "died with error $@\en"; 
\&    } else { 
\&        print "Hey, why aren\*(Aqt you dead?\en"; 
\&    }
.Ve
.PP
\&\fIeval()\fR passes any results from the joined thread back unmodified, so
if you want the return value of the thread, this is your only chance
to get them.
.Sh "Ignoring A Thread"
.IX Subsection "Ignoring A Thread"
\&\fIjoin()\fR does three things: it waits for a thread to exit, cleans up
after it, and returns any data the thread may have produced.  But what
if you're not interested in the thread's return values, and you don't
really care when the thread finishes? All you want is for the thread
to get cleaned up after when it's done.
.PP
In this case, you use the \fIdetach()\fR method.  Once a thread is detached,
it'll run until it's finished, then Perl will clean up after it
automatically.
.PP
.Vb 2
\&    use Thread; 
\&    $thr = Thread\->new( \e&sub1 ); # Spawn the thread
\&
\&    $thr\->detach; # Now we officially don\*(Aqt care any more
\&
\&    sub sub1 { 
\&        $a = 0; 
\&        while (1) { 
\&            $a++; 
\&            print "\e$a is $a\en"; 
\&            sleep 1; 
\&        } 
\&    }
.Ve
.PP
Once a thread is detached, it may not be joined, and any output that
it might have produced (if it was done and waiting for a join) is
lost.
.SH "Threads And Data"
.IX Header "Threads And Data"
Now that we've covered the basics of threads, it's time for our next
topic: data.  Threading introduces a couple of complications to data
access that non-threaded programs never need to worry about.
.Sh "Shared And Unshared Data"
.IX Subsection "Shared And Unshared Data"
The single most important thing to remember when using threads is that
all threads potentially have access to all the data anywhere in your
program.  While this is true with a nonthreaded Perl program as well,
it's especially important to remember with a threaded program, since
more than one thread can be accessing this data at once.
.PP
Perl's scoping rules don't change because you're using threads.  If a
subroutine (or block, in the case of \fIasync()\fR) could see a variable if
you weren't running with threads, it can see it if you are.  This is
especially important for the subroutines that create, and makes \f(CW\*(C`my\*(C'\fR
variables even more important.  Remember\*(--if your variables aren't
lexically scoped (declared with \f(CW\*(C`my\*(C'\fR) you're probably sharing them
between threads.
.Sh "Thread Pitfall: Races"
.IX Subsection "Thread Pitfall: Races"
While threads bring a new set of useful tools, they also bring a
number of pitfalls.  One pitfall is the race condition:
.PP
.Vb 4
\&    use Thread; 
\&    $a = 1; 
\&    $thr1 = Thread\->new(\e&sub1); 
\&    $thr2 = Thread\->new(\e&sub2); 
\&
\&    sleep 10; 
\&    print "$a\en";
\&