multhi threading concept in oops through java

Multi Tasking
Executing several tasks simultaneously is the concept
of multi tasking
There are two types of multi tasking
1.Process based
2. Thread based multi tasking

Process based multi tasking
Executing several tasks simultaneously where each
task is separate independent program(process) is
called process based multi tasking.
Example
While writing java program we can listen songs using
the same system, at the same time we can
download a file from the net.
All these tasks will be executed simultaneously and
independent of each other. Hence it is called
process based multi tasking.
Process based multi tasking is best suitable at OS level

Thread based multi tasking
Executing several tasks simultaneously where each
task is a separate independent part of the same
program is called Thread based multi tasking and
each independent part is called thread.
Thread based multitasking is best suitable at
programmatic level.

Differences between Process-based Multitasking & Thread-based Multitasking
Process-based Multitasking
1. Each process have its own address in memory i.e. each process
allocates separate memory area.
2. Process is heavyweight.
3. Cost of communication between the process is high.
4. Switching from one process to another require some time for
saving and loading registers, memory maps, updating lists etc.
Thread-based Multitasking
1. Threads share the same address space.
2. Thread is lightweight.
3. Cost of communication between the thread is low.

The main important application areas of
multithreading are
1.To develop multimedia graphics
2.To develop animations
3.To develop video games
4.To develop web servers and application servers etc.
When compared with old languages developing
multithreaded application is very easy. java
provides inbuilt support with rich API.
(Thread,Runnable,threadGropup)

Life cycle of a Thread
What is Thread
A thread is a lightweight sub process, a smallest unit
of processing. It is a separate path of execution.
A thread can be in one of the five states.
1.New/Born
2.Runnable/Ready
3.Running
4.Blocked
5.Terminated/Dead

multhi threading concept in oops through java

1. New : A thread begins its life cycle in the new
state. It remains in this state until the start()
method is called on it.
2. Runnable : After invocation of start() method on
new thread, the thread becomes runnable.
3. Running : A thread is in running state if the thread
scheduler has selected it.
4. Waiting : A thread is in waiting state if it waits for
another thread to perform a task. In this stage the
thread is still alive.
5. Terminated : A thread enter the terminated state
when it complete its task.

Creating a Thread
There are two ways to create a thread:
1.By extending Thread class
2.By implementing Runnable interface.

By extending Thread class
Class Mythread extends Thread
{
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println(“run method”);
}
}
}
Class Test
{
public static void main(String args[])
{
Mythread t=new Mythread();
t.start();
{
System.out.println(“main method”);
}
}
}

Case 1:
If we call run() method directly without using
start() method
public static void main( String args[] )
{
MyThread t = new MyThread();
t.run();
}

Difference between t.start() and t.run()
In the case of t.start() a new thread will be created
which responsible for the execution of run method.
But in the case of t.run() a new thread won’t be
created and run method will be executed just like a
normal method call by main thread.
Hence Multithreading won't be there.

Case 2:
A thread cannot be started twice. If you try to do so,
IllegalThreadStateException will be thrown.
Class Test
{
{
t.start();
t.start();//Exception thrown
}
}

By implementing Runnable interface
Class MyRunnable implements Runnable
{
public void run()
{
{
System.out.println(“child thread”);
}
}
}

Class ThreadDemo
{
{
MyRunnable r=new MyRunnable();
Thread t=new Thread(r);
t.start();
{
System.out.println(“main thread”);
}
}
}

MyRunnable r=new MyRunnable();
Thread t=new Thread();
Thread t1=new Thread(r);
Case1: t.start(); ->it execute thread run method.
Case 2:t.run();-> it executes thread run method.
Case3:t1.start();->it execute runnable run method
Case4:t1.run();->it executes runnable run method
without creating thread.
Case 5:r.start();->compile time error.
Case6: r.run();-> it executes runnable run method
without creating thread.

Getting and setting name of thread
Every thread in java has some name. it may be default
name generated by JVM or Customized name
provided by programmer.
We can get and set the name of a thread by using the
following two methods of thread class.
1.Public final String getName()
2.Public final void setName(String name)

Example
Class MyThread extends Thread
{
}
Class Test
{
{
System.out.println(Thread.currentThread().getName());
MyThraed t=new MyThread();
System.out.println(t.getName());
Thread.currentThread().setName(“CMR”);
System.out.println(Thread.currentThread().getName());
}
}

Creating Multiple Threads
class NewThread implements Runnable
{
String name; // name of thread
Thread t;
NewThread(String threadname) {
name = threadname;
t = new Thread(this, name);
//System.out.println("New thread: " + t);
t.start(); // Start the thread
}
public void run() {
try {
for (int i = 5; i > 0; i--) {
System.out.println(name + ": " + i);
Thread.sleep(1000);
}
} catch (InterruptedException e) {
System.out.println(name + "Interrupted");
}
System.out.println(name + " exiting.");
}
}

class MultiThreadDemo
{
{
new NewThread("One"); // start threads
new NewThread("Two");
new NewThread("Three");
try
{
Thread.sleep(10000);
}
catch (InterruptedException e)
{
System.out.println("Main thread Interrupted");
}
System.out.println("Main thread exiting.");
}
}

Thread Priorities
Every thread in java has some priority it may be
default priority generated by JVM or customized
priority provided by programmer
The valid range of thread priorities is 1 to 10.
where
1—MIN_PRIORITY
10---MAX_PRIORITY
Thread class defines the following constants to
represent some standard priorities
Thread.MIN_PRIORITY------1
Thread.NORM_PRIORITY-----5
Thraed.MAX_PRIORITY---------10

Thread scheduler will use priorities while allocating
processor.
The Thread which is having highest priority will get
chance first.
If two threads having same priority then we can’t
except exact execution order. it depends on thread
scheduler.
Thread class defines the following methods to get and
set priority of a thread.
public final int getPriority().
Public final void setPriority(int p)

Default Priority
The default priority only for the main thread is 5.
But for all remaining threads default priority will be
inherited form parent to child. i.e what ever priority
parent thread has the same priority will be there for
the child thread.

Example:
Class Mythread extends Thread
{
}
Class thredDemo
{
Public static void main(String args[])
{
System.out.println(Thread.currentThread().getPriority());
//Thread.currentThread().setPriority(8);
System.out.println(t.getPriority());
}
}

Setting the thread Priority
class Mythread extends Thread
{
public void run()
{
{
System.out.println("Child thread");
}
}
}

class ThredPriorityDemo1
{
{
t.setPriority(10);
t.start();
{
System.out.println("Main thread");
}
}
}
Output
Child thread –10 times
Main thread—10 times
note
Some platforms won’t provide support for thread priorities.

important methods of thread class
To prevent a thread execution the following methods
are used.
1.yield()
2.join()
3.sleep()

Yield()
Yield method pauses the currently executing
thread temporarily for giving a chance to the
remaining waiting threads of the same priority
to execute. If there is no waiting thread or all
the waiting threads have a lower priority then
the same thread will continue its execution.
Syntax
Public static native void yield()

Example
Class mythread extends Thread
{
Public void run()
{
For(int i=0;i<10;i++)
{
System.out.println(“child thread”);
Thread.yield();
}
}
}
Class ThreadYieldDemo
{
Public sataic void main(String args[])
{
t.strat();
{
System.out.println(“main thread”);
}
}
}

Join ()
If a thread wants to wait until completing some other thread
then we should go for join() method.
example
If a thread T1 wants to wait until completing T2 then T1 has to
call T2.join().If T1 executes T2.join() then immediately T1 will
be entered into waiting state until T2 completes. Once T2
completes then T1 can continue its execution.
Syntax
Public final void join() throws InterruptedException
Public final void join(long ms) throws InterruptedException
Public final void join(long ms, int ns) throws
InterruptedException

Example
class Mythread extends Thread
{
public void ru()
{
{
System.out.println("seetha Thread");
try
{
Thread.sleep(2000);
}
catch(InterruptedException e)
{
}
}
}
}
class ThreadJoinDemo
{
public static void main(String args[])throws InterruptedException
{
t.start();
t.join();
{
System.out.println("rama Thread");
}
}
}

Sleep ()
If a thread don’t want to perform any operation per a
particular amount of time then we should go for
sleep() method.
Syntax
Public static native void sleep(long ms) throws
Public static void sleep(long ms, int ns) throws

Example
class SlideRotator
{
public static void main(String args[])throws
{
{
System.out.println("Slide:"+i);
Thread.sleep(5000);
}
}
}

multhi threading concept in oops through java

More Related Content

Similar to multhi threading concept in oops through java (20)

More from Parameshwar Maddela (11)

Recently uploaded (20)

multhi threading concept in oops through java