CMSC 421 Spring 2004 Section 0202

CMSC 421 Spring 2004 Section 0202

Part II: Process ManagementChapter 5

Threads

Silberschatz, Galvin and Gagne 20025.2Operating System Concepts

Contents

Overview Multithreading Models Threading Issues Pthreads Solaris 2 Threads Windows 2000 Threads Linux Threads Java Threads


Lightweight Process and Heavyweight Process

Lightweight Process (LWP) or thread Basic unit of CPU control

Typically has private

– Id, PC, register set, stacks, local storage Shares OS resources with containing process

– Address space (Code section, data section), open files, etc

Heavyweight Process (HWP) Single thread


Single and Multithreaded Processes


Benefits

Responsiveness Interactive program responds to user even when some

threads are blocked doing other activities Resource Sharing

Shared address space, etc Economy

Lower overhead in creating and context switching threads than processes

context switch is 5 times faster Thread creation is 30 times faster

Utilization of multi-processor architectures Multiple threads can run on multiple processors


User Threads

Thread management done by a user-level threads library Kernel is unaware of user-level threads User-level threads are faster to create and manage However, if a thread is blocked on a system call, the

process is blocked too, and none of its other threads continues to run

Examples

- POSIX Pthreads

- Mach C-threads

- Solaris 2 threads


Kernel Threads

Thread management is supported by the Kernel Slower than user threads But kernel can schedule another thread when one thread

performs a blocking system call Examples

- Windows 95/98/NT/2000

- Solaris

- Tru64 UNIX

- BeOS

- Linux


Multithreading Models

Three models for implementing threads Many-to-One

One-to-One

Many-to-Many


Many-to-One Model


Many-to-One

Many user-level threads are mapped to a single kernel thread.

Multiple threads CANNOT run in parallel in a multiprocessor system

A blocked thread blocks its process Used on systems that do not support kernel threads. Example

Solaris 2 Green Threads Library


One-to-one Model


One-to-One

Each user-level thread maps to kernel thread. Can burden OS and slowdown application when many

threads are created (due to kernel overhead) Examples

- Windows 95/98/NT/2000

- OS/2


Many-to-Many Model


Many-to-Many Model

Allows many user level threads to be mapped to many kernel threads.

Allows the operating system to create a sufficient number of kernel threads, and map user threads to them

Addresses the shortcomings of the many-to-one and one-to-one models

Examples Solaris 2 Windows NT/2000 with the ThreadFiber package


Threading Issues

Semantics of fork() and exec() system calls Thread cancellation Signal handling Thread pools Thread specific data


fork() and exec() semantics

fork() Does it duplicate ALL threads of the forking process?

Two flavors: one that duplicates and one that does not Exec()

Replaces the whole process Including all threads (LWPs)


Thread Cancellation

Canceling a target thread Asynchronous cancellation (immediate termination) Deferred cancellation

Target thread periodically checks if it should terminate Issues:

reclaiming resources of cancelled target thread Shared resources with other threads

Cancellation points


Signal Handling

Signal => Notify the process of the occurrence of a certain event

Types of signals Synchronous

Delivered to the same process that generated the signal Illegal memory access, division by zero, overflow

Asynchronous Generally, delivered to a different process than the one

generating the signal <control><C>, timer expiry

Signals handled using Default signal handler (run by the kernel) User-defined signal handler


Signal Handling (Cont.)

Options for delivering signals (depending on signal) Only to the thread that generated the signal To all threads of a process To all threads not blocking the signal To a specific/dedicated thread

Threads many choose to block certain signals


Thread Pools and Thread-specific Data

Thread pools Creating a large number of threads in a system can exhaust

system resources Allocate a pool of thread’s Allocate available threads from the thread pool to a new

“thread” Reduces thread creation time when a request arrives

Thread-specific data Need for supporting private storage for threads that need to

manage their own private data


Pthreads

a POSIX standard (IEEE 1003.1c) API for thread creation, synchronization, and management

API specifies behavior of the thread library, implementation is up to development of the library.

Common in UNIX operating systems


Solaris 2 Threads

Implements the Pthread API + support for user and kernel threads

Uses LWP to multiplex user threads Implements many-to-many model

LWP reside in kernel space Allocates a kernel thread to each LWP User threads can be bound to a LWP or can be unbound Each user thread contains

Thread ID, register set (PC and stack pointer), stack, , and priority

Each LWP contains Register set for running user thread, stack, memory, and

accounting info


Solaris 2 Threads


Solaris Process


Pthreads Example

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

int sum = 0; /* shared data of the threads */void *runner(void *p);

int main(int argc, char *argv[]) {pthread_attr_t attr;pthread_t tid;pthread_attr_init(&attr);pthread_create(&tid, &attr, runner, argv[1]); /* create a thread and exec runner*/ pthread_join(tid, NULL); /* wait for thread to finish exec */printf(“%d\n”, sum);exit(0);

}

void *runner(void *param) {int n = 0, i;n = atoi(param);sum = 0;for(i=0; i;<n; i++) sum += i;pthread_exit(0);

}


Windows 2000 Threads

Implements the one-to-one mapping. Each thread contains

- a thread id

- register set

- separate user and kernel stacks

- private data storage area


Linux Threads

Thread creation is done through clone() system call Linux’s trick

Store process information in separate structures and use pointers to point to them instead of storing it directly in the data structure for the process

Clone() allows a child task to share the address space of the parent task (process)

Linux refers to them as tasks rather than threads.


Java Threads

Java threads may be created by: Extending Thread class Implementing the Runnable interface

Java threads are managed by the JVM. Java thread implementation depends on how the JVM is

implemented on the host OS Can be one-to-one for JVMs on Windows 2000 etc systems Can be many-tone on Solaris 2 green thread JVM systems


Java Thread Example

class Summation extends Thread {private int bound = 0;public Summation(int n) {

bound = n; }public void run() {

int sum = 0;for(int I=0; I<bound; I++)

sum += I;System.out.println(“Sum = “ + sum);

}}public class Test {

public static void main(String[] args) {Summation thr = new Summation(Integer.parseInt(args[0]);thr.start();

}}


Java Thread States

Documents

CMSC 421 Spring 2004 Section 0202