multithreading in java

two or more parts run concurrently - multitasking

each part is called a thread

each thread defines separate part of execution

multitasking - process based or thread based

process based - runs 2 or more programs concurrently

thread based - in a single program, 2 or more tasks are

performed simultaneously

difference in process based and thread based

process based thread based

1) more overhead 1) less overhead

2) heavyweight tasks that require 2) lightweight tasks that can

their own address spaces share address spaces

3) context switching is
3) context switching is expensive
inexpensive

4) interprocess communication is 4) interthread communication is

expensive and limited inexpensive

5) not under control of java 5) under control of java

multithreading better than single thread environment -

allows efficient use of CPU keeping the idle time of CPU to
a minimum

thread priorities - decides when to switch from one running

thread to next

rules that decide context switching

voluntarily relinquishing control - yielding, sleeping

or blocking - highest priority thread is given to CPU

multithreading in java 1
 preempted by higher priority thread - lower priority
thread that does not yield the processor is preempted by
higher priority thread - preemptive multitasking

multithreading is done using

thread class

runnable interface

methods defined by thread class

method meaning

getName() get a thread’s name

getPriority() get thread’s priority

isAlive() check if thread is running

join() wait for thread to terminate

run() entry point for thread

sleep() suspend thread for a period of time

start() start a thread

setName(String threadName) set thread’s name

main thread -

if a java program is started - main thread executes

immediately

child threads are spawned from here

last thread to finish execution - performs shutdown

actions

controlled using Thread object

call method currentThread() - public static member of

thread

syntax : static Thread currentThread()

multithreading in java 2
 ways to start a thread using runnable interface

class MyThread
class MyThread
implements Runnable
implements Runnable
{
{
Thread t2;
public void run()
MyThread()
{
{
t2 = new Thread(this);
}
t2.start();
}
}
public void run()
class prg
{
{
}
public static void
}
main(String[]args)
class prg
{
{
MyThread t = new
public static void
MyThread();
main(String args[])
Thread t2 = new
{
Thread(t);
MyThread t = new
t2.start();
MyThread();
}
}
}
}

explanation : made a explanation : made a

class MyThread which class MyThread which
implements Runnable implements Runnable
interface - indicates interface - indicates
that instances of this that instances of this
class can be executed class can be executed
by a thread by a thread

public void run : Thread t2 declares

declares a method named variable t2 of type
run which is required Thread - used to store
to be implemented when reference to Thread
a class implements the object
runnable interface -
this method contains MyThread() -
the code to be executed constructor of MyThread
when thread is started class
in main class

multithreading in java 3
 t2 = new Thread(this)
MyThread t = new creates a new Thread
MyThread() creates an object t2 and
instance of MyThread associates it with
class t which can be current instance of
used to start a new MyThread (which
thread explains use of this
keyword)
Thread t2 = new
Thread(t) - creates a t2.start() starts the
new Thread object t2 thread t2 - invokes run
and associates it with method of MyThread
MyThread instance t by instance
passing t as a
parameter to Thread() public void run :
constructor declares a method named
run which is required
t2.start() starts the to be implemented when
thread - invokes the a class implements the
run method of MyThread runnable interface -
instance t this method contains
the code to be executed
when thread is started
in main class
in main class,
MyThread t = new
MyThread() creates an
instance of MyThread
triggering constructor
and a new thread is
started

creating a thread

1) implementing runnable interface

to implement runnable, a class needs to implement run

method

inside run(), we define the code that constitutes the

new thread

run() establishes an entry point for another concurrent

thread of execution within our program

multithreading in java 4
 then instantiate an object of type Thread from within
the class that implements runnable

2) extending thread class

extending class must override run() method - entry point

for new thread

must also call start() method to begin execution of 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();
try

multithreading in java 5
 {
for(int i=5; i>0; i—)
{
System.out.println(”Main thread: “+i);
Thread.sleep(500);
}
}
catch(InterruptedException e)
{
System.out.println(”Main thread
interrupted”);
}
System.out.println(”main thread exiting”);
}
}

super() inside NewThread invokes the Thread

constructor public Thread(String
threadName)

multithreading in java 6