Chapter 4: Threads

 Definition
 Multithreading Models
 Threading Issues
 Pthreads (Unix)
 Solaris 2 Threads
 Windows 2000 Threads
 Linux Threads
 Java Threads

1
 Thread
 A Unix process (heavy-weight process HWP) can
create a number of threads (light-weight processes
LWP)

 Thread: a basic unit of CPU utilization, consisting of:

 Thread ID

 Program Counter

 Register set

 Stack

 A thread shares with other threads in the same

process:
 Code section
 Data section
 Other operating system resources, e.g., open files
2
 Thread Model

1 2 3

(a) Three processes each with one thread:

traditional Unix type system
(b) One process with three threads
3
The Thread Model (3)

Each thread has its own stack

4
Single and Multithreaded Processes

Program
Counter

5
Thread Model

6
 Thread Model

 Items shared by all threads in a process

 Items private to each thread
7
 Benefits
 Responsiveness:
 System continues working if a thread blocks: web browser

 Resource Sharing
 Several threads work on the same application

 Economy
 It is much more time consuming to create and manage a
HWP compare to a LWP; PCB vs. the thread context.
Creating a process is 30 time slower than creating a thread

 Utilization of MP Architectures
 Each thread can run in parallel on a different processor.

8
 Thread Usage

Spell-check &
Formatting

Chapter04-OSedition7Final.pptxReading &
writing
files
Scans key-stroke

A word processor with three threads

9
 User Threads

 Thread creation, scheduling, and management

done by user-level threads library:
 Fast to create; a blocked thread blocks all threads
Chapter04-OSedition7Final.pptx
 Examples
- POSIX Pthreads: provides recommendations
- Mach C-threads
- Solaris threads

10
Relationships Between ULT
States and Process States

Figure 4.6 Examples of the Relationships between User-Level Thread States and
Process States
All of the activity described in the preceding paragraph takes place in user space and within a single
process. The kernel is unaware of this activity. The kernel continues to schedule the process as a
unit and assigns a single execution state (Ready, Running, Blocked, etc.) to that process. The
following examples should clarify the relationship between thread scheduling and process
scheduling. Suppose that process B is executing in its thread 2; the states of the process and two
ULTs that are part of the process are shown in Figure 4.6a . Each of the following is a possible
occurrence:
1. The application executing in thread 2 makes a system call that blocks B. For
example, an I/O call is made. This causes control to transfer to the kernel. The kernel invokes the I/
O action, places process B in the Blocked state, and switches to another process. Meanwhile,
according to the data structure maintained by the threads library, thread 2 of process B is still in the
Running state. It is important to note that thread 2 is not actually running in the sense of being
executed on a processor; but it is perceived as being in the Running state by the threads library.
The corresponding state diagrams are shown in Figure 4.6b .
2. A clock interrupt passes control to the kernel and the kernel determines
that the currently running process (B) has exhausted its time slice. The kernel places process B in
the Ready state and switches to another process. Meanwhile, according to the data structure
maintained by the threads library, thread 2 of process B is still in the Running state. The
corresponding state diagrams are shown in Figure 4.6c .
3. Thread 2 has reached a point where it needs some action performed by thread
1 of process B. Thread 2 enters a Blocked state and thread 1 transitions from Ready to Running.
The process itself remains in the Running state. The corresponding state diagrams are shown in
Figure 4.6d .

In cases 1 and 2 ( Figures 4.6b and 4.6c ), when the kernel switches control back to process B,
execution resumes in thread 2. Also note that a process can be interrupted, either by exhausting its
time slice or by being preempted by a higher priority process, while it is executing code in the
threads library. Thus, a process may be in the midst of a thread switch from one thread to another
when interrupted. When that process is resumed, execution continues within the threads library, 12
which completes the thread switch and transfers control to another thread within that process.
 Implementing Threads in User Space

Runtime system includes

all the code necessary to:

- load programs,

- dynamically link libraries,

- manage memory, and

- handle exceptions.

A user-level threads package 13

 Kernel Threads
 Supported by the Kernel as kernel constructs:
 Slow to create and manage; kernel reschedules blocked
thread.

 Examples
- Windows 95/98/NT/2000
- Solaris
- Tru64 UNIX
- BeOS
Prof. Peter Buhr
- Linux
University of Waterloo
MicroC++
The starting point for the project was the development of high-level concurrency in an object-oriented
programming language. This approach is in contrast to programming with threads and locks, e.g., POSIX
threads, which deemed unreasonable because it is complicated and error-prone (like assembler
programming). An attempt was made to add concurrency without extending C++, but it turns out to be
impossible to build either an efficient or sound concurrency library due to fundamental language issues (not
problems with C++); therefore, a concurrent dialect of C++ was created, called MiroC++.
14
Implementing Threads in the Kernel

A threads package managed by the kernel

15
Thread Usage

Multithreaded
Web server

Dispatcher thread
Worker thread

16
 Multithreading Models
 Many-to-One

 One-to-One

 Many-to-Many

17
 Many-to-One
 Many user-level threads mapped to
single kernel thread.

 Used on systems that do not support

kernel threads.

 Threads can not run on multi-processor

system.

18
Many-to-One Model

19
 One-to-One
 Each user-level thread maps to kernel thread.

 Threads can run on a multi-processor system.

 Restriction on the number of the created threads.

 Examples
- Windows 95/98/NT/2000
- OS/2

20
One-to-one Model

21
 Many-to-Many Model
 Allows many user level threads to be mapped
(multiplexed) to many (not equal numbers) kernel
threads.

 Allows the operating system to create a sufficient

number of kernel threads (not equal number as one-
to-one); it can use multi-processor system.

 Solaris 2

 Windows NT/2000 with the ThreadFiber package

22
Many-to-Many Model

23
 Hybrid Implementations

Multiplexing user-level threads onto kernel- level

threads
24
 Threading Issues

 Semantics of fork() and exec() system calls.

 Create all threads or just one thread

 Exec() is executed immediately or not

 Thread cancellation
 Asynchronous: may damage incomplete task

 Synchronous: thread periodically scans for canceling: divide-by-zero / page

fault
 Signal handling (synchronous, async.)
 Signal: notifying the process that particular event happened

 Signal delivered to process and must be handled

 Default signal handler (can override by user handler)

 Thread pools

 Thread specific data

25
 Pthreads
 A POSIX standard (IEEE 1003.1c) API for
thread creation and synchronization.

 API specifies behavior of the thread library,

implementation is up to development of the
library.

 Common in UNIX operating systems.

26
Multi-threaded C program using Pthread API

#include <pthread.h>
#include <stdio.h>

int sum; /* this data is shared by the thread(s) */

void *runner(void *Param); /* the thread */

main (int argc, char *argv[]) /* The thread will begin control in this function */

pthread-t tid; /* the thread identifier */ void *runner(void *Param)

pthread-attr-t attr; /* set of thread attributes */
if (argc != 2) { {
fprintf(stderr,"usage: a.out <integer value>\n”) int upper = atoi(param);
exit(); int i;
} sum = 0;
if (atoi(argv[1]) < 0) { if (upper > 0) {
fprintf(stderr,"%d must be >= 0\n", atoi(argv[l])); for (i = 1; i <= upper; i++)
exit(); sum += i;
} }
/* get the default attributes */ pthread-exit(O);
pthread-attr-init (&attr); }
/* create the thread */
pthread-create (&tid, &attr, runner, argv [1]);
/* now wait for the thread to exit */
pthread-join (tid, NULL) ; 27
printf(“sum = %d\n",sum);
}
 Pthread attributes
http://www.cs.cf.ac.uk/Dave/C/node30.html

Attribute Value
scope PTHREAD_SCOPE_PROCESS
New thread is unbound not permanently attached to LWP.

Detachstate PTHREAD_CREATE_JOINABLE
Exit status of thread is served after the thread terminates.

stackaddr NULL
New thread has system-allocated stack address.

stacksize 1 megabyte
New thread has system-defined stack size.

inheritsched PTHREAD_INHERIT_SCHED
New thread inherits parent thread scheduling priority.

schedpolicy SCHED_OTHER
New thread uses Solaris-defined fixed priority scheduling; threads run until preempted by a higher-priority
thread or until they block or yield.

28
Solaris 2 Threads

29