12 multi-threading
DESCRIPTION
TRANSCRIPT
OOSSE - Java Lecture 11 1Apr 8, 2023
Multi-threading
OOSSE - Programming with JavaLecture 11
OOSSE - Java Lecture 11 2Apr 8, 2023
Objectives
In this lecture, we will:• Introduce threads • Discuss the Thread class and the Runnable
interface• Discuss interrupting threads• Introduce concepts of thread synchronization
OOSSE - Java Lecture 11 3Apr 8, 2023
Introduction
• A thread is a path of execution through a program• Many programs exist with just a single path of
execution• Operating systems (OS) often allow multiple
processes to co-exist and the OS shares processor time between them– The processes are isolated from each by the OS– They should not be able to overwrite each other’s
memory
• Languages like Java, C++ and C# allow a single application to have more than one thread of execution– a thread is the smallest unit of execution in the OS– Multiple threads in an application share the same
process space; they have access to the same memory
OOSSE - Java Lecture 11 4Apr 8, 2023
Why use threads?
• A lot of the time a computer is doing nothing!– Often waiting for user input or a slow peripheral device
• A computer can use any spare time by:– Multitasking – more than one process competing for the CPU– Mulit-threading - more than one thread competing for the
CPU
• Threads can be used to:– Allow the application to do something else while it is waiting – Start more than one task at a time rather than wait for one
to complete before starting another• Start processing data before all the data has loaded
– Maintain an active user interface• The interface does not die while processing takes place
OOSSE - Java Lecture 11 5Apr 8, 2023
Threads in Java
• There are two ways of creating threads in Java:• The Thread class can be subclassed and an
instance of this class used– This is most appropriate when the functionality of the
thread is largely independent
• Any class can implement the Runnable interface– An instance of the Thread class is constructed using
an instance of the Runnable class as an argument– This is appropriate when the thread must work in the
context of a specific object
• In either case the key method is run– The life of the thread exists through the execution of
run
OOSSE - Java Lecture 11 6Apr 8, 2023
Subclassing the Thread class
public class MyThread extends Thread {private String msg;private int num;
public MyThread(String m, int n){
msg = m;num = n;
}
public void run(){// the work of the thread takes place within the run
method// the thread terminates when the method ends
}}
OOSSE - Java Lecture 11 7Apr 8, 2023
Implementing the Runnable Interface
public class SimpleRun implements Runnable {private String msg;private int num;
public SimpleRun(String m, int n){
msg = m;num = n;
}
public void run(){// the work of the thread takes place within the run
method// the thread terminates when the method ends
}}
OOSSE - Java Lecture 11 8Apr 8, 2023
Starting a Thread
• Although the thread lives through the method run it is started by the method start
MyThread t1;
t1 = new MyThread("Hello",5);t1.start();
Thread t2;
t2 = new Thread(new SimpleRun("Pete", 20));t2.start();
• Any code can be placed in the run method but the method can be interrupted and must handle the exception– InterruptedException
• A thread can sleep if it wishes – normally while waiting – Thread.sleep( )
OOSSE - Java Lecture 11 9Apr 8, 2023
Sample Code for the run Method
public void run(){// output msg num timesfor (int i = 0; i < num; ++i){ System.out.println(msg + " " + i) ; try {
Thread.sleep(100); } catch (InterruptedException e) {
System.out.println("Thread interrupted: " + e); }}
}
OOSSE - Java Lecture 11 10Apr 8, 2023
Potential Problems with Threads
• It is very easy to start multiple threads• If the threads are largely independent then the design
is somewhat easier• However, at some stage threads normally want to share
some data– All threads in an application have access to the same
memory space
• When a thread may lose its time slice is unpredictable in most cases
• Access to shared resources by multiple threads may lead to:– Deadlock– Thread starvation– Race conditions
OOSSE - Java Lecture 11 11Apr 8, 2023
Thread Synchronization
• Thread safe applications can only be built by careful design and appropriate use synchronization facilities
• The most obvious problem is when one data object is accessed by more than one thread– If an update of the data is not completed then the
data may be in an inconsistent state if accessed by another thread
• It is possible to use locks to prevent multiple access to contentious code
• Java provides:– Synchronized methods– Synchronized blocks
OOSSE - Java Lecture 11 12Apr 8, 2023
Synchronized Methods
• A thread can lock an object temporarily– Typically until it has finished using it– When another object tries to access the same object
it is blocked
• Synchronized methods are used for object locking– Once a thread starts executing a synchronized
method it completes the method before any other thread can execute a synchronized method on the same object
– For example:public class MyData{
public synchronized void add ( … ) { … }public synchronized void renove ( … ) { … }
}
OOSSE - Java Lecture 11 13Apr 8, 2023
Wait and Notify
• If a synchronized cannot run to completion because it needs a resource then it cannot simply sleep– Sleeping does not release the lock– If the resource is provided by another synchronized
thread on the same object the supplying thread is blocked
• Instead of sleeping the thread can wait– Calling wait inside a synchronized method not only
makes the thread wait but also allows another thread to acquire the lock
• A waiting thread is blocked until another thread calls notifyAll or notify on the object for which the thread is waiting
OOSSE - Java Lecture 11 14Apr 8, 2023
Wait and Notify
• Consider adding to and removing from a data structure that can hold a limited amount of data:
public synchronized void add( … ) throws InterruptedException
{ while ( dataStructureIsFull() ) wait( ) ; // now add data … }
public synchronized void remove ( … ) { // assuming there is some data // remove data – space is now available to add notifyAll( ); // unblock all threads waiting on this lock }
OOSSE - Java Lecture 11 15Apr 8, 2023
Synchronized Blocks
• Synchronized methods automatically lock and unlock objects
• It is possible to apply a lock to a block of code– The lock is based upon a specific object
• The syntax is:synchronized ( someObject ){
// only one thread in the block of code at a time}
• It is normally better to think about thread safe code at the class level– Think about using synchronized methods in preference to
synchronized blocks
OOSSE - Java Lecture 11 16Apr 8, 2023
Summary
In this lecture we have:• Introduced threads • Discussed the Thread class and the Runnable
interface• Discussed interrupting threads• Introduced concepts of thread synchronization