This document discusses processes and threads in Perl programming. It defines a process as an instance of a running program, while a thread is a flow of control through a program with a single execution point. Multiple threads can run within a single process and share resources, while processes run independently. The document compares processes and threads, and covers creating and managing threads, sharing data between threads, synchronization, and inter-process communication techniques in Perl like fork, pipe, and open.

1. Perl Programming
Course
Processes and threads
Krassimir Berov
I-can.eu

2. Contents
1. What is a process
2. What is a thread
3. Comparison
4. Threads
• Threaded Program Models
• Creating and identifying Threads
• Thread Management
• Sharing Data
• Synchronization and control

3. Contents
5. Processes
• fork
• pipe
• open
• ...

4. What is a process
• process
• An instance of a running program
• Two or more separate processes could be
running the same program independently
at the same time
• A computer program itself is just a
passive collection of instructions, while a
process is the actual execution of those
instructions

5. What is a thread
• thread
• a thread is a flow of control through a program
with a single execution point
• there can be several threads of execution within
a process
• multiple threads share the same program code,
operating system resources and operating
system permissions as the process they belong
to

6. Comparison
• Thread versus process

7. Comparison
• Processes
• run independently and do not share
resources
• the fork() system call in UNIX causes creation
of a new process
• on Windows it is emulated by using threads
• The return value from fork() is used to
distinguish the parent from the child
• the parent receives the child's process id, but
the child receives zero

8. Comparison
• Processes (2)
• The new process (child process) is an exact
copy of the calling process (parent process)
except for the following:
• The child process has a unique process ID
• The child process has a different parent process
ID (i.e., the process ID of the parent process)
• The child process has its own copy of the parent's
descriptors

9. Comparison
• Threads
• A thread is an entity within a process that
consists of the schedulable part of the
process
• Creating new threads is faster
• Thread creation induces a peer
relationship between all the threads of a
process

10. Comparison
• Threads (2)
• All threads can share
• the parent process ID
• the process memory
• the process data
• the process permissions
• the Table with opened files

11. Comparison
• Threads (2)
• Every thread has its own
• thread ID
• separate point of execution
• thread-local storage

12. Threaded Program Models
• Three basic ways that you can structure a
threaded program
• Boss/Worker – one boss thread and one or more
worker threads
• Work Crew – several threads are created that do
essentially the same thing to different pieces of
data
• Pipeline – a task is divided into a series of steps
• the results of one step are passed to the thread
processing the next step
• Each thread does one thing to each piece of data

13. Creating
and identifying Threads
• Example
#threads_create.pl
BEGIN {
use Config;
$Config{useithreads}
or die('Threads support needed.');
}
use strict;use warnings;
use threads;
$|++;
while (1){
sleep 1;
my $thread_id = threads->self()->tid;
threads->create(&a_thread,$thread_id,[localtime]);
#OR
threads->new(&a_thread,$thread_id,[localtime]);
}
#...

14. Thread Management
• Waiting For A Thread To Exit
• join
• waits for a thread to exit,
• cleans up after it,
• returns any data the thread may have produced
#threads_management.pl
while ($i<30){
sleep 1;
my $odd = threads->create(&a_thread,[localtime]);
print $odd->join(),$/;
my $even = threads->new(&a_thread,[localtime]);
print $even->join(),$/;
$i++;
}
#...

15. Thread Management
• Ignoring A Thread
• detach
• the thread runs until it's finished
• Perl will clean up after it automatically
• may not be joined
• any return data is lost
#threads_management2.pl
while ($i<30){
sleep 1;
my $odd = threads->create(&a_thread,[localtime]);
$odd->detach();
my $even = threads->new(&a_thread,[localtime]);
$even->detach();
$i++;
}
#...

16. Thread Management
• Process and Thread Termination
• an action that terminates a process will
terminate all running threads.
• perl does an exit() when the main thread exits
#threads_management3.pl
my @threads = ();
while ($i<30){
push @threads, threads->new(&a_thread,[localtime]);
push @threads, threads->new(&a_thread,[localtime]);
$i++;
}
#uncomment and run again
#print $_->join foreach @threads;
#...

17. Sharing Data
• by default, no data is shared
• all the data associated with the current thread is
copied to the new thread, and is subsequently
private to that new thread
• all happens within the current process
#sharing_data.pl
my @threads = ();
while ($i<30){
push @threads, threads->new(&a_thread,[localtime]);
push @threads, threads->new(&a_thread,[localtime]);
$i++;
}
#uncomment and run again
#print $_->join foreach @threads;
#...

18. Sharing Data
• by default, no data is shared
• all the data associated with the current thread is
copied to the new thread, and is subsequently
private to that new thread
• all happens within the current process
• use threads::shared and the :shared attribute
to share data
• only simple values or references to shared
variables are allowed

19. Sharing Data
•Race conditions
● caused by unsynchronized access to shared
data
● there's no way to be sure that nothing has
happened to the shared data between the time
you access it and the time you update it
● $a += 5 or $a++ are not guaranteed to be
atomic

20. Synchronization and control
• lock
• takes a shared variable and puts a lock on it
• no other thread may lock the variable until the
variable is unlocked by the thread holding the lock
• Unlocking happens automatically when the locking
thread exits the block that contains the call to the
lock() function
• blocks the thread until the variable being locked is
available
• your thread can be sure that no other thread can lock
that variable until the block containing the lock exits
• does not prevent access to the variable, only lock
attempts

21. Synchronization and control
• lock – Example
#deadlock.pl
use threads; use threads::shared;
my $a :shared = 4;
my $b :shared = 'foo';
my $thr1 = threads->create(sub {
lock($a);
sleep(2);
lock($b);
$a++; $b .= $a;
})->join ;
my $thr2 = threads->create(sub {
lock($b);
sleep(2);
lock($a);
$a++; $b .= $a;
})->join ;
print $thr1,$/,$thr2,$/;

22. Synchronization and control
• Queues
• A queue is a special thread-safe object
that lets you put data in one end and take
it out the other without having to worry
about synchronization issues
• add lists of scalars onto the end with
enqueue()
• pop scalars off the front of it with
dequeue()

23. Synchronization and control
• Semaphores
• generic locking mechanism
• behave very much like lockable scalars,
except that they can't hold data
• must be explicitly unlocked
• by default, semaphores behave like locks
• see also: perlthrtut/Advanced Semaphores

24. Processes
• fork
Does a fork(2) system call to create a new
process running the same program at the same
point
• returns the child pid to the parent process, 0 to the
child process, or undef if the fork is unsuccessful
• file descriptors are shared, while everything else is
copied
• beginning with v5.6.0, Perl will attempt to flush all
files opened for output before forking the child
process

25. Processes
• fork – Example
#io-socket-tcp-server-fork.pl
#...
sub REAPER {
1 until (-1 == waitpid(-1, WNOHANG));
$SIG{CHLD} = &REAPER;
}
$SIG{CHLD} = &REAPER;
print "Server ($0) running on port $port...n";
while (my $connection = $server->accept) {
if (my $pid = fork){
handle_connection($connection,$$);
}
}
$server->close();

26. IPC
• pipe READHANDLE,WRITEHANDLE
• Opens a pair of connected pipes like the
corresponding system call.
• Perl's pipes use IO buffering, so you may need to set
$| to flush your WRITEHANDLE after each command,
depending on the application.
pipe (READ, WRITE);
select WRITE;
$| = 1;
#...

27. IPC
• system PROGRAM LIST
• exactly the same thing as exec LIST , except
that a fork is done first, and the parent
process waits for the child process to
complete
• The return value is the exit status of the
program as returned by the wait call
• see perlfunc/system

28. IPC
• open
open(MAIL, "|/usr/lib/sendmail -oi -t")
or die "can't fork sendmail: $!";
print MAIL <<EOF;
From: $0
To: you@example.com
Subject: blah
EOF
close(MAIL)

29. Processes and threads
• Ressources
• Professional Perl Programming
(Chapter 22 – Creating and Managing Processes)
• perldoc perlthrtut
• http://en.wikipedia.org/wiki/Process_%28computing%29
• http://en.wikipedia.org/wiki/Thread_%28computer_science%29
• http://gauss.ececs.uc.edu/Users/Franco/ForksThreads/forks.html
• perldoc perlipc
• perldoc perlfork

30. Processes and threads
Questions?