12 multi-threading

OOSSE - Java Lecture 11 1Apr 8, 2023

Multi-threading

OOSSE - Programming with JavaLecture 11


Objectives

In this lecture, we will:• Introduce threads • Discuss the Thread class and the Runnable

interface• Discuss interrupting threads• Introduce concepts of thread synchronization


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


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


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


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

}}


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

}}


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


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

}


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


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


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 ( … ) { … }

}


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


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 }


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


Summary

In this lecture we have:• Introduced threads • Discussed the Thread class and the Runnable

interface• Discussed interrupting threads• Introduced concepts of thread synchronization

12 multi-threading

Documents

Transcript of 12 multi-threading