Object Oriented Programming

Instructor Name:
Lecture-23 - 24
 Today’s Lecture

 Multithreading

2
 Multithreading

Introduction
 Performing One Action at a time is nice

 Human Body performs variety of actions in parallel – concurrent

 Java makes concurrency available to you through the language and APIs.

 Java programs can have multiple threads of execution, where each thread has
its own method-call stack and program counter, allowing it to execute
concurrently with other threads while sharing with them application-wide
resources such as memory.

 This capability is called multithreading

3
 Multithreading

Introduction – Concurrent Programming Uses

 When downloading a large file (e.g., an image, an audio clip or a
video clip) over the Internet, the user may not want to wait until the
entire clip downloads before starting the playback.
 To solve this problem, multiple threads can be used—one to
download the clip, and another to play it.
 These activities proceed concurrently.
 To avoid choppy playback, the threads are synchronized(that is, their
actions are coordinated) so that the player thread doesn’t begin until
there’s a sufficient amount of the clip in memory to keep the player
thread busy.
 The Java Virtual Machine (JVM) creates threads to run programs and
threads to perform housekeeping tasks such as garbage collection.
4
 Multithreading

Introduction – Concurrent Programming is Difficult

 Writing multithreaded programs can be tricky.
 Why
 Try to read three books concurrently
 After this experiment, you’ll appreciate many of the challenges of
multithreading
 Switching between the books,
 reading briefly,
 remembering your place in each book,
 moving the book you’re reading closer so that you can see it and
pushing the books you’re not reading aside— and many more

5
 Multithreading

Introduction – Use Prebuilt Classes

 Programming concurrent applications is difficult and error prone.
 If you must use synchronization in a program, you should follow
some simple guidelines.
 Use existing classes from the Concurrency APIs
 If you need even more complex capabilities, use interfaces Lock and
Condition

6
 Multithreading

Thread State: Life Cycle of Thread

 At any time, a thread is said to be in one of severalthread states
 We actually need to understand what’s going on “under the hood” in
a Java multithreaded environment.

7
 Multithreading

Thread State: Life Cycle of Thread

 New: A new thread begins its life cycle in the new state. It remains in this
state until the program starts the thread. It is also referred to as a born thread.
 Runnable: After a newly born thread is started, the thread becomes runnable.
A thread in this state is considered to be executing its task.
 Waiting: Sometimes, a thread transitions to the waiting state while the thread
waits for another thread to perform a task. A thread transitions back to the
runnable state only when another thread signals the waiting thread to
continue executing.
 Timed waiting: A runnable thread can enter the timed waiting state for a
specified interval of time. A thread in this state transitions back to the
runnable state when that time interval expires or when the event it is waiting
for occurs. Timed waiting and waiting threads cannot use a processor, even if
one is available.
 Terminated ( Dead ): A runnable thread enters the terminated state when it
completes its task or otherwise terminates. 8
 Multithreading

Operating System View of Runnable State

 The operating system hides these states from the Java Virtual Machine (JVM)
 When a thread first transitions to the runnable state from the new state, it’s in
the ready state.
 A ready thread enters the running state (i.e., begins executing) when the
operating system assigns it to a processor—also known as dispatching the
thread.
 In most operating systems, each thread is given a small amount of processor
9
time—called a quantum or timeslice—with which to perform its task.
 Multithreading

Operating System View of Runnable State

 Deciding how large the quantum should be is a key topic in operating
systems courses so we don’t need to go into details.
 When thread’s quantum expires, the thread returns to the ready state, and the
operating system assigns another thread to the processor.
 Transitions between the ready and running states are handled solely by the
operating system.
 The JVM does not “see” the transitions—it simply views the thread as being
runnable
 The process that an operating system uses to determine which thread to
dispatch is called thread scheduling and is dependent on thread priorities.

10
 Creating Thread by Implementing runnable
Interface
Step 1
 As a first step you need to implement a run() method provided by Runnable
interface.
 This method provides entry point for the thread and you will put you
complete business logic inside this method.
 Following is simple syntax of run() method:
public void run()
Step 2
 Instantiate a Thread object using the following constructor:
Thread(Runnable threadObj, String threadName);
 Where, threadObj is an instance of a class that implements the Runnable
interface and threadName is the name given to the new thread.
Step 3
 Once Thread object is created, you can start it by calling start( ) method,
which executes a call to run( ) method.
void start( ); 11
Creating Thread by Implementing runnable
Interface
class RunnableDemo implements Runnable {
private Thread t;
private String threadName;

RunnableDemo( String name){

threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName
+ ", " + i);
// Let the thread sleep for a while.
Thread.sleep(50);
}
12
}
Creating Thread by Implementing runnable
Interface
catch (InterruptedException e) {
System.out.println("Thread " + threadName + "
interrupted.");
}
System.out.println("Thread " + threadName + "
exiting.");
}

public void start ()

{
System.out.println("Starting " + threadName );
if (t == null)
{
t = new Thread (this, threadName);
t.start ();
}
}
13
}
Creating Thread by Implementing runnable
Interface

public class TestThread {

public static void main(String args[]) {

RunnableDemo R1 = new RunnableDemo( "Thread-1");

R1.start();

RunnableDemo R2 = new RunnableDemo( "Thread-2");

R2.start();

RunnableDemo R3 = new RunnableDemo( "Thread-3");

R3.start();
}
}

14
Creating and Executing Threads with Executor
Framework

Creating and Executing

Threads
with
Executor Framework
15
Creating and Executing Threads with Executor
Framework
Creating Concurrent Tasks with the Runnable Interface
 You implement the Runnable interface (of package java.lang) to specify a task
that can execute concurrently with other tasks.
 The Runnable interface declares the single method run, which contains the
code that defines the task that a Runnable object should perform.

Executing Runnable Obects with an Executor

 To allow a Runnable to perform its task, you must execute it.
 An Executor object executes Runnables.
 An Executor does this by creating and managing a group of threads called a
thread pool.
 When an Executor begins executing a Runnable, theExecutor calls the
Runnable object’s run method, which executes in the new thread

16
Creating and Executing Threads with Executor
Framework
Executing Runnable Obects with an Executor
 The Executor interface declares a single method named execute which accepts
a Runnable as an argument.
 The Executor assigns every Runnable passed to its execute method to one of
the available threads in the thread pool.
 If there are no available threads, the Executor creates a new thread or waits
for a thread to become available and assigns that thread the Runnable that
was passed to method execute.
 Using an Executor has many advantages over creating threads yourself.
 Executors can reuse existing threads to eliminate the overhead of creating a
new thread for each task and can improve performance by optimizing the
number of threads to ensure that the processor stays busy, without creating so
many threads that the application runs out of resources.

17
Creating and Executing Threads with Executor
Framework
Using Class Executors to Obtain an Executor Service
 The ExecutorService interface (of package java.util.concurrent) extends
Executor and declares various methods for managing the life cycle of
anExecutor.
 An object that implements theExecutorService interface can be created using
static methods declared in class Executors(of packagejava.util.concurrent).

18
Creating and Executing Threads with Executor
Framework
Implementing the RunnableInterface
 Class PrintTask implements Runnable , so that multiple PrintTasks can
 execute concurrently
 Variable sleepTime stores a random integer value from 0 to 5 seconds
 Each thread running a PrintTask sleeps for the amount of time specified by
sleep Time, then outputs its task’s name and a message indicating that it’s
done sleeping.
 A PrintTask executes when a thread calls the PrintTask’s run method, display
a message indicating the name of the currently executing task and that the
task is going to sleep for sleepTime milliseconds
 At this point, the thread loses the processor, and the system allows another
thread to execute.
 In the next slides we have complete code for threading with this technique

19
Creating and Executing Threads with Executor
Framework
import java.util.Random;
public class PrintTask implements Runnable
{
private final int sleepTime; // random sleep time for thread

private final String taskName; // name of task

private final static Random generator = new Random();

// constructor

public PrintTask( String name )

{
taskName = name; // set task name
// pick random sleep time between 0 and 5 seconds

sleepTime = generator.nextInt(5000);// milliseconds

} // end PrintTask constructor 20

Creating and Executing Threads with Executor
Framework
// method run contains the code that a thread will execute

public void run()

{
try{ // put thread to sleep for sleepTime amount of time

System.out.printf("%s going to sleep for %d

milliseconds.\n“, taskName, sleepTime );
} // end try

catch(Exception exception ){//InterruptedException

System.out.printf("%s %s\n", taskName,
"terminated prematurely due to interruption" );
} // end catch

// print task name

System.out.printf( "%s done sleeping\n", taskName );

} // end method run

} // end class PrintTask 21

Creating and Executing Threads with Executor
Framework
Using theExecutorService to Manage Threads that Execute PrintTasks
 Class TaskExecutor uses an ExecutorService object to manage threads that
execute PrintTasks.
 First create and name three PrintTasks to execute.
 We use Executors method newCachedThreadPool to obtain an
ExecutorService that’s capable of creating new threads as they’re needed by
the application.
 These threads are used by ExecutorService (threadExecutor) to execute the
Runnables.

22
Creating and Executing Threads with Executor
Framework
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
public class TaskExecutor
{
public static void main( String[] args )
{
// create and name each runnable
PrintTask task1 =new PrintTask("task1");
PrintTask task2 =new PrintTask("task2");
PrintTask task3 =new PrintTask("task3");

System.out.println( "Starting Executor");

23
Creating and Executing Threads with Executor
Framework
// create ExecutorService to manage threads
ExecutorService threadExecutor =
Executors.newCachedThreadPool();

// start threads and place in runnable state

threadExecutor.execute(task1); // start task1
threadExecutor.execute(task2); // start task2
threadExecutor.execute(task3); // start task3

// shut down worker threads when their tasks complete

threadExecutor.shutdown();

System.out.println( "Tasks started, main ends.\n");

} // end main
}
24
25