• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
12 multi-threading
 

12 multi-threading

on

  • 478 views

 

Statistics

Views

Total Views
478
Views on SlideShare
478
Embed Views
0

Actions

Likes
0
Downloads
21
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • Part of this lecture will be reserved for working through solutions to selected exercises from last week. Notes relating to this do not appear in the slides.

12 multi-threading 12 multi-threading Presentation Transcript

  • Multi-threading OOSSE - Programming with Java Lecture 11Dec 21, 2012 OOSSE - Java Lecture 11 1
  • Objectives In this lecture, we will: • Introduce threads • Discuss the Thread class and the Runnable interface • Discuss interrupting threads • Introduce concepts of thread synchronizationDec 21, 2012 OOSSE - Java Lecture 11 2
  • 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 memoryDec 21, 2012 OOSSE - Java Lecture 11 3
  • 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 placeDec 21, 2012 OOSSE - Java Lecture 11 4
  • 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 runDec 21, 2012 OOSSE - Java Lecture 11 5
  • 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 } }Dec 21, 2012 OOSSE - Java Lecture 11 6
  • 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 } }Dec 21, 2012 OOSSE - Java Lecture 11 7
  • 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( )Dec 21, 2012 OOSSE - Java Lecture 11 8
  • Sample Code for the run Method public void run(){ // output msg num times for (int i = 0; i < num; ++i) { System.out.println(msg + " " + i) ; try { Thread.sleep(100); } catch (InterruptedException e) { System.out.println("Thread interrupted: " + e); } } }Dec 21, 2012 OOSSE - Java Lecture 11 9
  • 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 conditionsDec 21, 2012 OOSSE - Java Lecture 11 10
  • 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 blocksDec 21, 2012 OOSSE - Java Lecture 11 11
  • 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 ( … ) { … } }Dec 21, 2012 OOSSE - Java Lecture 11 12
  • 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 waitingDec 21, 2012 OOSSE - Java Lecture 11 13
  • 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 }Dec 21, 2012 OOSSE - Java Lecture 11 14
  • 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 blocksDec 21, 2012 OOSSE - Java Lecture 11 15
  • Summary In this lecture we have: • Introduced threads • Discussed the Thread class and the Runnable interface • Discussed interrupting threads • Introduced concepts of thread synchronizationDec 21, 2012 OOSSE - Java Lecture 11 16