Post on 11-Jan-2016
description
transcript
1
Chapter 5 Threads
2
Contents Overview Benefits User and Kernel Threads Multithreading Models Solaris 2 Threads Java Threads
3
Thread A thread, sometimes called a lightweight
process, is a basic unit of CPU utilization Comprises
A thread IDA program counterA register setA stack
Shares with other threads belonging to the same process:Code sectionData sectionOther resources
§ 5.1
4
Thread A traditional, or heavyweight, process has a
single thread of control.
5
Thread Examples Busy web server has many concurrently
accessing clients. Java program connecting to the server will be
blocked until the connection is made since Java has no concept of asynchronous. Solution: another thread with timeout sleeping checking the connecting thread when wake up.
6
Benefits Responsiveness – continue running even if part
of it is blocked Resource sharing – allows an application to have
several different threads of activity all within the same address space
Economy – it is more economical to create and context switch threads than process
Utilization of multiprocessor architectures – in single-processor architecture, multithread is only an illusion
§ 5.2
7
User Threads User threads are supported by user-level threads
library without the need for kernel intervention. Fast to create and manage. Examples
- POSIX Pthreads
- Mach C-threads
- Solaris threads
§ 5.3
8
Kernel Threads Kernel threads are supported directly by the OS
in kernel space Slower to create and manage. Examples
- Windows 95/98/NT
- Solaris
- Digital UNIX
§ 5.3.2
9
Multithreading Models Many-to-One Model
One-to-One Model
Many-to-Many Model
§ 5.4
10
Many-to-One Model Many user-level threads mapped to single kernel
thread. Used on systems that do not support multiple
kernel threads. Efficient, but the entire process will be blocked if
a thread makes a blocking system call Since only one thread can access the kernel at a
time, multiple threads are unable to run in parallel on multiprocessors
11
Many-to-One Model
12
One-to-One Model Each user thread maps to a kernel thread. Provides more concurrency than the many-to-one Drawback: creating a user thread requires
creating the corresponding kernel thread … burden the performance … most system restrict the number of threads supported.
Examples- Windows 95/98/NT- OS/2
13
One-to-One Model
14
Many-to-Many Model Multiplex many user threads to a smaller or equal
number of kernel threads. Developers can create as many user threads as
necessary and the corresponding kernel threads can run in parallel on a multiprocessor.
Examples:SolarisIRIXDigital UNIX
15
Many-to-Many Model
16
Solaris 2 Threads Solaris 2 is a version of UNIX Supported only traditional heavy-weight
processes within a single thread of control until 1992
Intermediate level thread: lightweight processes (LWP)
Each process contains at least one LWP Only user-level threads currently connected to an
LWP accomplish work
§ 5.5
17
Solaris 2 Threads
18
Solaris Process (略 )
19
Java Threads Java is unique because it provides support for
creation and management of threads at the language level, it provides commands that allows the programmer to create and manipulate threads of control within the program.
All Java program comprise at least a single thread of control.
Java Threads May be Created by:Extending Thread class Implementing the Runnable interface
§ 5.6
20
Extending the Thread Classclass Worker1 extends Thread{
public void run() {System.out.println(“I am a Worker Thread”);
}}public class First{
public static void main(String args[]) {Worker1 runner = new Worker1();
runner.start();
System.out.println(“I am the main thread”);}
}
Worker1Thread
Worker1
runner
run
start
21
Extending the Thread Class An object of this derived class will run as a
separate thread of control in the JVM. Two threads are created by the JVM:
The thread associated with the application – the thread that starts execution at the main() method.
The runner thread that is created explicitly with the start() method.
22
Extending the Thread Classclass Worker1 extends Thread{
public void run() {System.out.println(“I am a Worker Thread”);
}}public class First{
public static void main(String args[]) {Worker runner = new Worker1();
runner.start();
System.out.println(“I am the main thread”);}
}
1
2
23
The Runnable Interface Another option to create a separate thread is to
define a class that implements the Runnable interface.
The runnable interface is defined aspublic interface Runnable{
public abstract void run();}
When a class implements Runnable, it must define a run() method.
24
Implementing the Runnable Interfaceclass Worker2 implements Runnable{
public void run() {System.out.println(“I am a Worker Thread”);
}}public class Second{
public static void main(String args[]) {Runnable runner = new Worker2();Thread thrd = new Thread(runner);thrd.start();
System.out.println(“I am the main thread”);}
}
25
Why Implements Runnable ? Since Java does not support multiple inheritance, if a
class is already derived from another class, it will not also be able to extend the Thread class.
Example: an applet already extends the Applet class has to also implement the Runnable interface:
public class ThreadedApplet extends Applet implements Runnable
{ ………}
Unless a class requires multithreading and is already extended, we will adopt the approach of extending the Thread class.
26
Java Thread Management Java APIs for managing threads:
suspend() – suspends execution of the currently running thread.
sleep() – puts the currently running thread to sleep for a specified amount of time.
resume() – resumes execution of a suspended thread. stop() – stops execution of a thread.
§ 5.6.2
27
Applets with threads Applets are natural examples for multithreading
because they commonly have graphics, animation, and audio – all good candidates as threads.
start() method of an applet is called when an applet is first displayed. If the user leaves the web page or the applet scrolls off the screen, the applet’s stop() method is called.
The destroy() method of an applet is called when the applet is removed from the browser’s cache.
28
Java Thread States A Java thread can be in one of four states:
New: when an object for the thread is createdRunnable: When a thread’s run() method is
invoked, the thread moves from the New to the Runnable state.
Blocked: when performing a blocking statement, such as doing I/O, or if it invokes methods like sleep() or suspend().
Dead: when its run() method terminates or when its stop() method is called.
§ 5.6.3
29
Java Thread States
It is not possible to determine the exact state of a thread, however, isAlive() method returns a boolean value to determine whether or not a thread is dead.
30
Threads and the JVM In addition to a Java application program
contains several different threads of control, there are several threads running asynchronously on behalf of the JVM handling system-level tasks such as memory management and graphics control.
§ 5.6.4
31
JVM and Host OS The typical implementation of the JVM is on top
of a host OS. This allows the JVM to hide the implementation details of the underlying OS and to provide a consistent, abstract environment that allows Java programs to operate on any platform that supports a JVM.
Windows NT: one-to-one, each Java thread for a JVM running on NT maps to a kernel thread
Solaris 2: many-to-one Solaris 2.6: many-to-many
§ 5.6.5
32
Producer Consumer Problempublic class Server {
public Server() {// first create the message bufferMessageQueue mailBox = new MessageQueue();
// now create the producer and consumer threads Producer producerThread = new Producer(mailBox); Consumer consumerThread = new Consumer(mailBox); producerThread.start(); consumerThread.start(); } public static void main(String args[]) {
Server server = new Server(); }}
33
Producer Consumer Problem
MessageQueue
send receive
vector
queue
mailBox
consumerproducer
producerThread consumerThread
Server
34
Producer Threadclass Producer extends Thread {
public Producer(MessageQueue m) {mbox = m;
}
public void run() { while (true) {
// produce an item & enter it into the buffer Date message = new Date(); mbox.send(message); } } private MessageQueue mbox;}
Producer MessageQueue
send receive
vector
queue
mBoxThread
35
Consumer Threadclass Consumer extends Thread {
public Consumer(MessageQueue m) {mbox = m;
}
public void run() { while (true) {
Date message = (Date)mbox.receive();if (message != null)
// consume the message}
} private MessageQueue mbox;}
Consumer MessageQueue
send receive
vector
queue
mBoxThread