Multithreading

Multithreading:
A thread is a single sequence of execution within a program refers to multiple threads of control within a single program each program can run multiple threads of control within it, e.g., Chat Client

Motivation
If we are designing a software for chatting, we need to execute a program, in background, that will read message from the server. And another program that will help you to type new message using some GUI. The important thing is that both of these programs should run simultaneously, which is only possible if your system contains multiple processors.

Threads and Processes

CPU

main run Process 1 Process 2 Process 3 Process 4

GC

What are Threads Good For?

To maintain responsiveness of an application during a long running task To enable cancellation of separable tasks Some problems are intrinsically parallel To monitor status of some resource (e.g., DB) Some APIs and systems demand it (e.g., Swing)

Application Thread
When we execute an application:
1. The JVM creates a Thread object whose task is defined by the main() method 2. The JVM starts the thread

3. The thread executes the statements of the program one by one

4. After executing all the statements, the method returns and the thread dies
5

Multiple Threads in an Application

Each thread has its private run-time stack If two threads execute the same method, each will have its own copy of the local variables the methods uses

However, all threads see the same dynamic memory, i.e., heap (are there variables on the heap?) Two different threads can act on the same object and same static fields concurrently
6

Creating Threads
There are two ways to create our own
Thread object
1. Implementing the Runnable interface 2. Subclassing the Thread class and instantiating a new object of that class

In both cases the run() method should be implemented

7

Thread class
In java, we create threads by using Thread

class defined in java.lang package.

Thread t = new Thread();

t.start();
By creating a new Thread object, we can

launch a separate thread of execution(os

level thread) with its very own call stack.

 But there is one problem. The thread doesnt actually do anything. So it will dies virtually the instant its born. And when the thread dies, its new stack disappears.

We are missing one key component:

The threads job. We need the code that we want to have run by a separate thread.

We can say that each thread needs a job to do.

Runnable interface
Runnable is an interface defined in java.lang package. The object of a class, which will implement Runnable interface, will be a job for thread. class MyRunnable implements Runnable { public void run() { } }

Runnable interface defines only one method, run().

Launch a new Thread

Make a job for thread:
Runnable job = new MyRunnable();

Make a Thread object:

Thread myThread = new Thread(job).

Start the thread:

myThread.start();

By simply creating an object of Thread class does not create a new thread. The invocation of start() method creates a new thread of execution, means a separate call stack by invoking the run() method.

 The JVM calls the main method.

main() starts a new thread. Runnable job = new MyRunnable(); Thread myThread = new Thread(job); myThread.start();

main()
Main thread

start() main()
Main thread

run()
new thread

Threads working on different data/job/object

public static void main(String []args) {

Runnable job1 = new MyRunnable();

Thread myThread1= new Thread(job1); myThread1.start();

Runnable job2 = new MyRunnable();

Thread myThread2 = new Thread(job2); myThread2.start();

}
13

Creating thread using Thread class

We can also create the thread by extending

the Thread class.

The extending class must override the run( )

method, which is the entry point for the

new thread. It must also call start( ) to begin execution of the new thread.

14

public class CustomThread extends Thread { public CustomThread() { } // Override the run method in Runnable public void run() { // Tell system how to perform this task } }
15

public class Client { public void someMethod() { CustomThread thread1 = new CustomThread(); thread1.start(); CustomThread thread2 = new CustomThread(); thread2.start(); } }

16

 This approach is, however, not recommended, because it mixes the task and the mechanism of running the task. Separating the task from the thread is a preferred design.

Moreover, logically, if we think Thread class as a worker, then we should not extend it until we need a more specific worker.

17

Thread Methods
void start() Creates a new thread and makes it runnable This method can be called only once void run() The new thread begins its life inside this method void stop() (deprecated)

The thread is being terminated

18

Thread Methods
void yield() Causes the currently executing thread object to temporarily pause and allow other threads to execute Allow only threads of the same priority to run Does not release any lock void sleep(int m) The thread sleeps for m milliseconds Does not release any lock
19

join() method
The join() method tells the current thread to

wait for the other thread to complete.

public static void main(String[] args) {
When main thread will execute this statement, it will pause and t1 thread Runnable job = new MyRunnable(); will start its execution. Main thread will not start Thread t1 = new Thread(job); again until t1 gets executed completely.
t1.setName("FIRST"); try { t1.join(); } catch (InterruptedException ex) { ex.printStackTrace(); } }

20

Demo : Multiple Threads

Demonstrate using netbeans

21

sleep method
Show sleep demo in netbeans

22

Thread Priority
Every thread has a priority When a thread is created, it inherits the priority of the thread that created it

The priority values range from 1 to 10,

in increasing priority

23

Thread Priority (cont.)

The priority can be adjusted subsequently using the setPriority() method The priority of a thread may be obtained using
getPriority()

Priority constants are defined:

MIN_PRIORITY=1 MAX_PRIORITY=10 NORM_PRIORITY=5

The main thread is created with priority NORM_PRIORITY

24

Thread priority demo

Demonstrate using netbeans

25

Scheduling Threads
start()

threads, ready to execute

Ready queue

Newly created Thread objects Currently executed thread I/O operation completes
Waiting for I/O operation to be Waiting to be notified Sleeping Waiting to enter a synchronized

completed

section
26

Thread State Diagram

Alive Running new ThreadExample(); New Thread while () { } Runnable Dead Thread run() method returns Blocked

thread.start();

Object.wait() Thread.sleep() blocking IO call waiting on a monitor

27

Example
public class PrintThread1 extends Thread { String name; public PrintThread1(String name) { this.name = name; } public void run() { for (int i=1; i<100 ; i++) {

try {
sleep((long)(Math.random() * 100)); } catch (InterruptedException ie) { } System.out.print(name);

}
}
28

Example (cont)
public static void main(String args[]) { PrintThread1 a = new PrintThread1("*"); PrintThread1 b = new PrintThread1("-"); a.start(); b.start(); } }

29

Daemon Threads
Daemon threads are background threads, that provide services to other threads, e.g., the garbage collection thread The Java VM will not exit if non-Daemon threads are executing The Java VM will exit if only Daemon threads are executing

Daemon threads die when the Java VM exits

Q: Is the main thread a daemon thread?
30

Thread and the Garbage Collector

Can a Thread object be collected by the

garbage collector while running?

If not, why? If yes, what happens to the execution thread?

When can a Thread object be collected?

31

Concurrency
An object in a program can be changed by

more than one thread

Demo using netbeans

32

Synchronized methods
The synchronized is a keyword used in Java

ensures that only one Java thread execute

an object's synchronized method at a time

33

Monitors
Each object has a monitor that is a token

used to determine which application thread

has control of a particular object. In execution of a synchronized method, access to the object monitor must be gained before the execution. Access to the object monitor is queued
34

Monitor (cont.)
Entering a monitor is also referred to as locking the monitor, or acquiring ownership of the monitor If a thread A tries to acquire ownership of a monitor and a different thread has already entered the monitor, the current thread (A) must wait until the other thread leaves the monitor
35

 Locks are not per method, they are per

object.
Goal of synchronization is to protect data. So

we synchronize the methods that access the

data

36

Critical Section
The synchronized methods define critical

sections
Execution of critical sections is mutually

exclusive.

37

Example
public class BankAccount { private float balance; public synchronized void deposit(float amount){ balance += amount; } public synchronized void withdraw(float amount){ balance -= amount; } }

38

t3

t2

t1

Critical Sections
deposit()

Bank Account

39

Java Locks are Reentrant

Is there a problem with the following code?

public class Test { public synchronized void a() { b(); System.out.println(I am at a); } public synchronized void b() { System.out.println(I am at b); } }
40

Static Synchronized Methods

Marking a static method as synchronized,

associates a monitor with the class itself

The execution of synchronized static

methods of the same class is mutually

exclusive.

41

Synchronized Statements
A monitor can be assigned to a block:
synchronized(object) { some-code }

It can also be used to monitor access to a data element that is not an object, e.g., array:
void addName(String name) { synchronized(this) { lastName = name;
//these two statements will execute as an atomic operation

nameCount++;
} nameList.add(name);}
42

The Followings are Equivalent

public synchronized void a() { // some code } public void a() { synchronized (this) { // some code

}
}
43

The Followings are Equivalent

public static synchronized void a() { // some code } public void a() { synchronized (this.getClass()) { // some code

}
}
44

Example
public class MyPrinter { public MyPrinter() {} public synchronized void printName(String name) { for (int i=1; i<100 ; i++) { try { Thread.sleep((long)(Math.random() * 100)); } catch (InterruptedException ie) {} System.out.print(name); }

}
}
45

Example
public class PrintThread2 extends Thread { String name; MyPrinter printer; public PrintThread2(String name, MyPrinter printer){ this.name = name; this.printer = printer; } public void run() { printer.printName(name); } }
46

Example (cont)
public class ThreadsTest2 { public static void main(String args[]) { MyPrinter myPrinter = new MyPrinter(); PrintThread2 a = new PrintThread2("*, printer); PrintThread2 b = new PrintThread2("-, printer);

PrintThread2 c = new PrintThread2("=, printer);

a.start(); b.start(); c.start(); } }

What will happen?

47

Deadlock Example
public class BankAccount { private float balance;

public synchronized void deposit(float amount) { balance += amount; }

public synchronized void withdraw(float amount) { balance -= amount; } public synchronized void transfer (float amount, BankAccount target) { withdraw(amount); target.deposit(amount); } }
48

public class MoneyTransfer implements Runnable { private BankAccount from, to; private float amount; public MoneyTransfer( BankAccount from, BankAccount to, float amount){ this.from = from; this.to = to; this.amount = amount; } public void run() { source.transfer(amount, target); }

49

BankAccount aliceAccount = new BankAccount(); BankAccount bobAccount = new BankAccount(); ...

// At one place Runnable transaction1 = new MoneyTransfer(aliceAccount, bobAccount, 1200); Thread t1 = new Thread(transaction1); t1.start();
// At another place Runnable transaction2 = new MoneyTransfer(bobAccount, aliceAccount, 700); Thread t2 = new Thread(transaction2); t2.start();

50

Deadlocks
t1 t2

aliceAccount

bobAccount
transfer() withdraw() deposit()

transfer()

withdraw() deposit()

51

Thread Synchronization
We need to synchronized between

transactions, for example, the consumerproducer scenario

52

Wait and Notify

Allows two threads to cooperate

Based on a single shared lock object

Marge put a cookie, wait and notify Homer Homer eat a cookie, wait and notify Marge
Marge put a cookie wait and notify Homer Homer eat a cookie wait and notify Marge

53

The wait() Method

The wait() method is part of the java.lang.Object interface It requires a lock on the objects monitor to execute It must be called from a synchronized method, or from a synchronized segment of code.

54

The wait() Method

wait() causes the current thread to wait until

another thread invokes the notify() method

or the notifyAll() method for this object Upon call for wait(), the thread releases ownership of this monitor and waits until another thread notifies the waiting threads of the object
55

The wait() Method

wait() looks similar to yield()!!! Both take the current thread off the execution stack and

force it to be rescheduled

However, wait() is not automatically put back into the scheduler queue
notify() must be called in order to get a thread back into the schedulers queue The objects monitor must be reacquired before the threads run can continue What is the difference between wait and sleep?56

Wait/Notify Sequence

1. synchronized(lock){ 2. lock.wait(); 9. consumeResource(); 10. }

Lock Object

3. produceResource() 4. synchronized(lock) 5. lock.notify(); 6.}

7. Reacquire lock 8.Return from wait()

Consumer Thread

Producer Thread

57

Wait/Notify Sequence

1. synchronized(lock){ 2. lock.wait(); 9. consumeResource(); 10. }

Lock Object

3. produceResource() 4. synchronized(lock) 5. lock.notify(); 6.}

7. Reacquire lock 8. Return from wait()

Consumer Thread

Producer Thread

58

Wait/Notify Sequence

1. synchronized(lock){ 2. lock.wait(); 9. consumeResource(); 10. }

Lock Object

3. produceResource() 4. synchronized(lock) 5. lock.notify(); 6.}

7. Reacquire lock 8. Return from wait()

Consumer Thread

Producer Thread

59

Wait/Notify Sequence

1. synchronized(lock){ 2. lock.wait(); 9. consumeResource(); 10. }

Lock Object

3. produceResource() 4. synchronized(lock) 5. lock.notify(); 6.}

7. Reacquire lock 8. Return from wait()

Consumer Thread

Producer Thread

60

Wait/Notify Sequence

1. synchronized(lock){ 2. lock.wait(); 9. consumeResource(); 10. }

Lock Object

3. produceResource() 4. synchronized(lock) 5. lock.notify(); 6.}

7. Reacquire lock 8. Return from wait()

Consumer Thread

Producer Thread

61

Wait/Notify Sequence

1. synchronized(lock){ 2. lock.wait(); 9. consumeResource(); 10. }

Lock Object

3. produceResource() 4. synchronized(lock) 5. lock.notify(); 6.}

7. Reacquire lock 8. Return from wait()

Consumer Thread

Producer Thread

62

Wait/Notify Sequence

1. synchronized(lock){ 2. lock.wait(); 9. consumeResource(); 10. }

Lock Object

3. produceResource() 4. synchronized(lock) 5. lock.notify(); 6.}

7. Reacquire lock 8. Return from wait()

Consumer Thread

Producer Thread

63

Wait/Notify Sequence

1. synchronized(lock){ 2. lock.wait(); 9. consumeResource(); 10. }

Lock Object

3. produceResource() 4. synchronized(lock) 5. lock.notify(); 6.}

7. Reacquire lock 8. Return from wait()

Consumer Thread

Producer Thread

64

Wait/Notify Sequence

1. synchronized(lock){ 2. lock.wait(); 9. consumeResource(); 10. }

Lock Object

3. produceResource() 4. synchronized(lock) 5. lock.notify(); 6.}

7. Reacquire lock 8. Return from wait()

Consumer Thread

Producer Thread

65

Wait/Notify Sequence

1. synchronized(lock){ 2. lock.wait(); 9. consumeResource(); 10. }

Lock Object

3. produceResource() 4. synchronized(lock) 5. lock.notify(); 6.}

7. Reacquire lock 8. Return from wait()

Consumer Thread

Producer Thread

66

Wait/Notify Sequence

1. synchronized(lock){ 2. lock.wait(); 9. consumeResource(); 10. }

Lock Object

3. produceResource() 4. synchronized(lock) 5. lock.notify(); 6.}

7. Reacquire lock 8. Return from wait()

Consumer Thread

Producer Thread

67