you might find that things aren't quite what you expect. 

 It's very important to remember when dealing with Perl 

 threads that Perl Threads Are Not X Threads, for all values 

 of X. They aren't POSIX threads, or 

 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. 

 A possibly-threaded program using a possibly-threaded module might have code like this: 

  

  

  use Config; 

  if ($Config{usethreads}) { 

 # We have threads 

 } else { 

 } 

  

  

 __Creating Threads__ 

  

  

  use Thread; 

 $Param3 = 

  sub sub1 { 

 print 

 The subroutine runs like a normal Perl subroutine, and the call to new Thread returns whatever the subroutine returns. 

  

  

 ''eval()'', but into its own thread: 

  

  

  use Thread qw(async); 

  $thr = async { 

 while( 

  print 

 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 ''async()'' treats the following block as an anonymous subroutine, so the semicolon is necessary. 

  

  

  use Thread; 

 $thr = new Thread 

  sub sub1 { return 

 In the example above, the ''join()'' 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, ''join()'' also performs any OS 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 ''detach()'' method instead. ''detach()'' is covered later in the article. 

  

  

  

  

  use Thread qw(async); 

 use Thread::Queue; 

 $thr = async { 

 You create the queue with new Thread::Queue. Then you can add lists of scalars onto the end with ''enqueue()'', and pop scalars off the front of it with ''dequeue()''. A queue has no fixed size, and can grow as needed to hold everything pushed on to it. 

  

  

 If a queue is empty, ''dequeue()'' blocks until another 

  

  use Thread qw(yield); 

 use Thread::Semaphore; 

 my $semaphore = new Thread::Semaphore; 

  $thr1 = new Thread 

  sub sample_sub { 

 sleep 1; 

 $semaphore- 

 The three invocations of the subroutine all operate in sync. The semaphore, though, makes sure that only one thread is accessing the global variable at once. 

  

  

  

  use Thread qw(yield); 

  new Thread 

  sub sync_sub :locked { 

 print 

  sub thread_sub { 

 my $ThreadID = shift @_; 

 print 

 __OS-Related References__ 

  

  

 Boykin, Joseph, David Kirschen, Alan Langerman, and Susan 

 ISBN 0-201-52739-1. 

  

  

 Tanenbaum, Andrew S. Distributed Operating Systems. Prentice 

 0-201-31006-6. 

  

  

 Le Sergent, T. and B. Berthomieu. ``Incremental 

 Architectures'' in Memory Management: Proc. of the 

 International Workshop IWMM 92, St. Malo, 

 France, September 1992, Yves Bekkers and Jacques Cohen, eds. 

 Springer, 1992, ISBN 3540-55940-X (real-life