oops 2

Darshan Institute of Engineering & Technology, Rajkot
Jayesh.vagadiya@darshan.ac.in
9537133260
Computer Engineering Department
Prof. Jayesh D. Vagadiya
Object Oriented Programming -I
(3140705)
Unit-12
Concurrency /
Multithreading

 Looping
Outline
Multithreading
Life Cycle of Thread
Creating a Thread
Using Thread Class
Using Runnable Interface
Join
Synchronized

Prof. Jayesh D. Vagadiya #3140705 (OOP-I)  Unit 12 – Multithreading 3
What is Multithreading?
 Multithreading in Java is a process of executing multiple threads simultaneously.
 A thread is a lightweight sub-process, the smallest unit of processing.
 Multiprocessing and multithreading, both are used to achieve multitasking.
 Threads use a shared memory area. They don't allocate separate memory area
so saves memory, and context-switching between the threads takes less time
than process.
 A thread goes through various stages in its life cycle. For example, a thread is
born, started, runs, and then dies.
 Lets see the life cycle of the thread.

Life cycle of a Thread
 There are 5 stages in the life cycle of the
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 waiting thread to continue.
 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.
 Terminated: A runnable thread enters the
new
runnable
timed
waiting
waiting
terminate
d
Program starts
thread
unlock
signal
signalAll
aw
ait
lock
await
sleep
Interval
expires
T
h
r
e
a
d
c
o
m
p
l
e
t
e
s
T
a
s
k

Creating a Thread in Java
 There are two ways to create a Thread
1. extending the Thread class
2. implementing the Runnable interface

1) Extending Thread Class
 One way to create a thread is to create a new class that extends Thread, and
then to create an instance of that 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.
class NewThread extends Thread {
NewThread() {
super("Demo Thread");
System.out.println("Child thread: " + this);
start(); // Start the thread
}
public void run() {
try {
for (int i = 5; i > 0; i--) {
System.out.println("Child Thread: " +
i);
Thread.sleep(500);
}
} catch (InterruptedException e) {
System.out.println("Child interrupted.");
}
System.out.println("Exiting child thread.");
}}
class ExtendThread {
public static void main(String args[]) {
new NewThread(); // create a new thread
try {
for (int i = 5; i > 0; i--) {
System.out.println("Main Thread: " +
i);
Thread.sleep(1000);
}
} catch (InterruptedException e) {
System.out.println("Main thread
interrupted.");
}
System.out.println("Main thread exiting.");
}
}

2) Implementing Runnable Interface
 To implement thread using Runnable interface, Runnable interface needs to
be implemented by the class.
class NewThread implements Runnable
 Class which implements Runnable interface should override the run() method
which containts the logic of the thread.
public void run( )
 Instance of Thread class is created using following constructor.
Thread(Runnable threadOb, String threadName);
 Here threadOb is an instance of a class that implements the Runnable
interface and the name of the new thread is specified by threadName.
 start() method of Thread class will invoke the run() method.

Example Runnable Interface

Thread using Executor Framework
 Steps to execute thread using Executor Framework are as follows:
1. Create a task (Runnable Object) to execute
2. Create Executor Pool using Executors
3. Pass tasks to Executor Pool
4. Shutdown the Executor Pool

Example Executable Framework
class Task implements Runnable {
private String name;
public Task(String s) {
name = s;
}
public void run() {
try {
for (int i = 1; i<=5; i++)
{
System.out.println(nam
e+" - task number -
"+i);
Thread.sleep(1000);
}
System.out.println(name+"
complete");
}
catch(InterruptedException e) {
e.printStackTrace();
}
}
}
import java.util.concurrent.*;
public class ExecutorThreadDemo {
public static void main(String[]
args) {
Runnable r1 = new Task("task
1");
2");
3");
4");
5");
ExecutorService pool =
Executors.newFixedThreadPool(3)
;
pool.execute(r1);
pool.execute(r2);
pool.execute(r3);
pool.execute(r4);
pool.execute(r5);
pool.shutdown();
}
}

Thread Synchronization
 When we start two or more threads within a program, there may be a situation
when multiple threads try to access the same resource and finally they can
produce unforeseen result due to concurrency issues.
 For example, if multiple threads try to write within a same file then they may
corrupt the data because one of the threads can override data or while one
thread is opening the same file at the same time another thread might be
closing the same file.
 So there is a need to synchronize the action of multiple threads and make sure
that only one thread can access the resource at a given point in time.
 Java programming language provides a very handy way of creating threads and
synchronizing their task by using synchronized methods & synchronized blocks.

Problem without synchronization (Example)
class Table {
void printTable(int n) {
for (int i = 1; i <= 5; i++) {
System.out.print(n * i + " ");
try {
Thread.sleep(400);
} catch (Exception e) {
System.out.println(e);
}
}
}
}
class MyThread1 extends
Thread {
Table t;
MyThread1(Table t) {
this.t = t;
}
public void run() {
t.printTable(5);
}
}
Thread {
Table t;
this.t = t;
}
public void run() {
t.printTable(100);
}
}
public class TestSynchronization {
public static void main(String
args[]){
Table obj = new Table();
MyThread1 t1 = new MyThread1(obj);
t1.start();
t2.start();
}
}

Solution with synchronized method
class Table {
synchronized void printTable(int n) {
for (int i = 1; i <= 5; i++) {
try {
Thread.sleep(400);
}
}
}
}
Thread {
Table t;
this.t = t;
}
public void run() {
t.printTable(5);
}
}
Thread {
Table t;
this.t = t;
}
public void run() {
t.printTable(100);
}
}
args[]){
t1.start();
t2.start();
}
}

Solution with synchronized blocks
class Table {
void printTable(int n) {
for (int i = 1; i <= 5; i++) {
try {
Thread.sleep(400);
}
}
}
}
Thread {
Table t;
this.t = t;
}
public void run() {
synchronized (t) {
t.printTable(5);
}
}
}
Thread {
Table t;
this.t = t;
}
public void run() {
synchronized (t) {
t.printTable(100);
}
}
}
args[]){
t1.start();
t2.start();
}
}

oops 2

Recommended

More Related Content

Similar to oops 2 (20)

Recently uploaded (20)

oops 2