1 User Threads Benefits Responsiveness Thread management done by - - PDF document

1
SMART_READER_LITE
LIVE PREVIEW

1 User Threads Benefits Responsiveness Thread management done by - - PDF document

Contents CMSC 421 Spring 2004 Section 0202 Overview Multithreading Models Threading Issues Pthreads Solaris 2 Threads Windows 2000 Threads Part II: Process Management Linux Threads Chapter 5 Java Threads Threads


slide-1
SLIDE 1

1

CMSC 421 Spring 2004 Section 0202

Part II: Process Management

Chapter 5 Threads

Silberschatz, Galvin and Gagne 2002 5.2 Operating System Concepts

Contents

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

Silberschatz, Galvin and Gagne 2002 5.3 Operating System Concepts

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

Silberschatz, Galvin and Gagne 2002 5.4 Operating System Concepts

Single and Multithreaded Processes

slide-2
SLIDE 2

2

Silberschatz, Galvin and Gagne 2002 5.5 Operating System Concepts

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

Silberschatz, Galvin and Gagne 2002 5.6 Operating System Concepts

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

Silberschatz, Galvin and Gagne 2002 5.7 Operating System Concepts

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

Silberschatz, Galvin and Gagne 2002 5.8 Operating System Concepts

Multithreading Models

Three models for implementing threads

Many-to-One One-to-One Many-to-Many

slide-3
SLIDE 3

3

Silberschatz, Galvin and Gagne 2002 5.9 Operating System Concepts

Many-to-One Model

Silberschatz, Galvin and Gagne 2002 5.10 Operating System Concepts

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

Silberschatz, Galvin and Gagne 2002 5.11 Operating System Concepts

One-to-one Model

Silberschatz, Galvin and Gagne 2002 5.12 Operating System Concepts

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
slide-4
SLIDE 4

4

Silberschatz, Galvin and Gagne 2002 5.13 Operating System Concepts

Many-to-Many Model

Silberschatz, Galvin and Gagne 2002 5.14 Operating System Concepts

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

  • f 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

Silberschatz, Galvin and Gagne 2002 5.15 Operating System Concepts

Threading Issues

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

Silberschatz, Galvin and Gagne 2002 5.16 Operating System Concepts

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)

slide-5
SLIDE 5

5

Silberschatz, Galvin and Gagne 2002 5.17 Operating System Concepts

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

Silberschatz, Galvin and Gagne 2002 5.18 Operating System Concepts

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

Silberschatz, Galvin and Gagne 2002 5.19 Operating System Concepts

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

Silberschatz, Galvin and Gagne 2002 5.20 Operating System Concepts

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

slide-6
SLIDE 6

6

Silberschatz, Galvin and Gagne 2002 5.21 Operating System Concepts

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

Silberschatz, Galvin and Gagne 2002 5.22 Operating System Concepts

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

Silberschatz, Galvin and Gagne 2002 5.23 Operating System Concepts

Solaris 2 Threads

Silberschatz, Galvin and Gagne 2002 5.24 Operating System Concepts

Solaris Process

slide-7
SLIDE 7

7

Silberschatz, Galvin and Gagne 2002 5.25 Operating System Concepts

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);

}

Silberschatz, Galvin and Gagne 2002 5.26 Operating System Concepts

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

Silberschatz, Galvin and Gagne 2002 5.27 Operating System Concepts

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.

Silberschatz, Galvin and Gagne 2002 5.28 Operating System Concepts

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

slide-8
SLIDE 8

8

Silberschatz, Galvin and Gagne 2002 5.29 Operating System Concepts

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(); }

}

Silberschatz, Galvin and Gagne 2002 5.30 Operating System Concepts

Java Thread States