Basic of Multithreading in JAva

MULTITHREADING
BY LECTURER SURAJ PANDEY CCT COLLEGE

Multithreading in java
Multithreading in java is a process of executing multiple
threads simultaneously.
Thread is basically a lightweight sub-process, a smallest unit
of processing. Multiprocessing and multithreading, both are
used to achieve multitasking.
But we use multithreading than multiprocessing because
threads share a common memory area. They don't allocate
separate memory area so saves memory, and context-
switching between the threads takes less time than process.
Java Multithreading is mostly used in games, animation etc.

Advantage of Java Multithreading
1) It doesn't block the user because threads are
independent and you can perform multiple operations at
same time.
2) You can perform many operations together so it
saves time.
3) Threads are independent so it doesn't affect other threads
if exception occur in a single thread.

Multitasking
Multitasking is a process of executing multiple tasks
simultaneously. We use multitasking to utilize the CPU.
Multitasking can be achieved by two ways:
1. Process-based Multitasking(Multiprocessing)
2. Thread-based Multitasking(Multithreading)

1) Process-based Multitasking (Multiprocessing)
Each process have its own address in memory i.e. each
process allocates separate memory area.
Process is heavyweight.
Cost of communication between the process is high.
Switching from one process to another require some time for
saving and loading registers, memory maps, updating lists
etc.

2) Thread-based Multitasking (Multithreading)
Threads share the same address space.
Thread is lightweight.
Cost of communication between the thread is low.

What is Thread in java
A thread is a lightweight sub process, a smallest unit of
processing. It is a separate path of execution.
Threads are independent, if there occurs exception in one
thread, it doesn't affect other threads. It shares a common
memory area.

As shown in the above figure, thread is executed inside the
process. There is context-switching between the threads.
There can be multiple processes inside the OS and one
process can have multiple threads.

Life cycle of a Thread (Thread States)
During the life time of a thread, there are many states it can
enter. They include:
1. Newborn state
2. Runnable state
3. Running state
4. Blocked state
5. Dead state
a thread is always in one of these five states. It can move from
one state to another via a variety of ways as shown in fig.

Newborn
Running Runnable
Blocked
Dead
Start
Stop
Stop
Stop
resume
notify
suspend
sleep wait
Idle
Thread(notR
unnable)
New
Thread
Active
Thread
yield
Killed
Thread
State transition diagram of a thread

Newborn state:
When we create a thread object, the thread is born and is said to be
in newborn state. The thread is not yet schedule for running. At this
state, we can do only one of the following things with it:
Schedule it for running using start() method.
Kill it using stop() method
If scheduled, it moves to the runnable state . If we attempt to use any other
method at this stage, an exception will be thrown.

Runnable State:
The runnable state means that the thread is ready for execution and
is waiting for the availability of the processor. That is, the thread
has joined the queue of threads that are waiting for execution. If all
threads have equal priority, then they are given time slots for
execution in round robin fashion, i.e., first-come first-serve
manner. The thread that relinquishes control joins the queue at the
end and again waits for its turn. This process of assigning time to
threads is known as time-slicing.
However, if we want a thread to relinquish control, to another
thread to equal priority before its turn comes, we can do so by
using the yield() method

Running state:
Running means that the processor has given its time to the thread
for its execution. The thread runs until it relinquishes control on its
own or its preempted by a higher priority thread. A running thread
may relinquish its control in one of the following situations.
It has been suspended using suspend() method. A suspended thread can be
revived by using the resume() method. This approach is useful when we want
to suspend a thread for some time due to certain reason, but do not want to
kill it.
It has been made to sleep, we can put a thread to sleep for a specific time
period using the method sleep(time) where time is milliseconds. This means
that the thread is out of the queue during this time period. The thread re-
enters the runnable state as soon as this time period is elapsed.

It has been told to wait until some event occurs. This is done
using the wait() method. The thread can be scheduled to run
again using the notify() method.

Blocked state:
A thread is said to be blocked when it is prevented from entering
into the runnable state and subsequently the running state. This
happens when the thread is suspended, sleeping, or waiting in order
to satisfy certain requirements. A blocked thread is considered “
not runnable” but not dead and therefore fully qualified to run
again.

Dead state:
Every thread has a life cycle. A running thread ends its life when it
has completed executing its run() method. It is a natural death.
However, we can kill it by sending the stop message to it at any
state this causing a premature death to it. A thread can be killed as
soon it is born, or while it is running, or even when it is in “not
runnable” (blocked) condition.

How to create thread
There are two ways to create a thread:
1. By extending Thread class
2. By implementing Runnable interface.
Thread class:
Thread class provide constructors and methods to create and
perform operations on a thread.Thread class extends Object
class and implements Runnable interface.

Commonly used methods of Thread class:
 public void run(): is used to perform action for a thread.
 public void start(): starts the execution of the thread.JVM calls the run() method on
the thread.
 public void sleep(long miliseconds): Causes the currently executing thread to
sleep (temporarily cease execution) for the specified number of milliseconds.
 public void join(): waits for a thread to die.
 public void join(long miliseconds): waits for a thread to die for the specified
miliseconds.
 public int getPriority(): returns the priority of the thread.
 public int setPriority(int priority): changes the priority of the thread.
 public String getName(): returns the name of the thread.
 public void setName(String name): changes the name of the thread.
 public Thread currentThread(): returns the reference of currently executing
thread.
 public int getId(): returns the id of the thread.
 public Thread.State getState(): returns the state of the thread.

public boolean isAlive(): tests if the thread is alive.
public void yield(): causes the currently executing thread
object to temporarily pause and allow other threads to execute.
public void suspend(): is used to suspend the
thread(depricated).
public void resume(): is used to resume the suspended
thread(depricated).
public void stop(): is used to stop the thread(depricated).
public void interrupt(): interrupts the thread.
public boolean isInterrupted(): tests if the thread has been
interrupted.
public static boolean interrupted(): tests if the current
thread has been interrupted.

Runnable interface:
The Runnable interface should be implemented by any class
whose instances are intended to be executed by a thread.
Runnable interface have only one method named run().
public void run(): is used to perform action for a thread.
Starting a thread:
start() method of Thread class is used to start a newly
created thread. It performs following tasks:
A new thread starts(with new callstack).
The thread moves from New state to the Runnable state.
When the thread gets a chance to execute, its target run()
method will run.

1)By extending Thread class
class Multi extends Thread{
public void run(){
System.out.println("thread is running...");
}
public static void main(String args[]){
Multi t1=new Multi();
t1.start();
}
}

2)By implementing the Runnable
interface
class Multi3 implements Runnable{
public void run(){
System.out.println("thread is running...");
}
Multi3 m1=new Multi3();
Thread t1 =new Thread(m1);
t1.start();
}
}

Thread Scheduler in Java
Thread scheduler in java is the part of the JVM that
decides which thread should run.
There is no guarantee that which runnable thread will be
chosen to run by the thread scheduler.
Only one thread at a time can run in a single process.
The thread scheduler mainly uses preemptive or time slicing
scheduling to schedule the threads.

Sleep method in java
The sleep() method of Thread class is used to sleep a thread
for the specified amount of time.
Syntax of sleep() method in java
The Thread class provides two methods for sleeping a
thread:
public static void sleep(long miliseconds)throws
InterruptedException
public static void sleep(long miliseconds, int
nanos)throws InterruptedException

Example of sleep method in java
 class TestSleepMethod1 extends Thread{
public void run(){
  for(int i=1;i<5;i++){
    try{Thread.sleep(500);}catch(InterruptedException e){System.out.println(e);}
    System.out.println(i);
  }
}
  TestSleepMethod1 t1=new TestSleepMethod1();
  TestSleepMethod1 t2=new TestSleepMethod1();
t1.start();
  t2.start();
}
 }

Output:
 1
 1
 2
 2
 3
3
 4
 4

The join() method:
The join() method waits for a thread to die. In other words,
it causes the currently running threads to stop executing
until the thread it joins with completes its task.
Syntax:
public void join()throws InterruptedException
public void join(long milliseconds)throws

Example of join() method

class TestJoinMethod1 extends Thread{
public void run(){
  for(int i=1;i<=5;i++){
   try{
    Thread.sleep(500);
   }catch(Exception e)
{
System.out.println(e);}
  System.out.println(i);
  }
}
TestJoinMethod1 t1=new TestJoinMethod1();
t1.start();
try{
  t1.join();
}catch(Exception e){System.out.println(e);}

t2.start();
t3.start();
}
}

 Output:1
 2
 3
 4
 5
 1
 1
 2
 2
 3
 3
 4
 4
 5
 5
 BY LECTURER SURAJ PANDEY CCT COLLEGE

As you can see in the above example,when t1 completes its
task then t2 and t3 starts executing.

getName(),setName(String) and getId() method:

 class TestJoinMethod3 extends Thread{
  public void run(){
   System.out.println("running...");
  }
  System.out.println("Name of t1:"+t1.getName());
  System.out.println("id of t1:"+t1.getId());
  t1.start();
  t2.start();
  t1.setName(“Ravi");
  System.out.println("After changing name of t1:"+t1.getName());
}
 }

Output:Name of t1:Thread-0
 Name of t2:Thread-1
 id of t1:8
 running...
 After changling name of t1:Ravi
 running...


The currentThread() method:
The currentThread() method returns a reference to the
currently executing thread object.
Syntax:
public static Thread currentThread()

Example of currentThread() method
class TestJoinMethod4 extends Thread
 {
public void run(){
  System.out.println(Thread.currentThread().getName());
}
}
t1.start();
  t2.start();
}
 }

Output:Thread-0
 Thread-1

Naming a thread:
The Thread class provides methods to change and get the
name of a thread.
public String getName(): is used to return the name of a
thread.
public void setName(String name): is used to change
the name of a thread.

class TestMultiNaming1 extends Thread{
public void run(){
   System.out.println("running...");
  }
  TestMultiNaming1 t1=new TestMultiNaming1();
  TestMultiNaming1 t2=new TestMultiNaming1();
t1.start();
  t2.start();
t1.setName("Sonoo Jaiswal");
  System.out.println("After changing name of t1:"+t1.getName());
}
}

Output:
Name of t1:Thread-0
Name of t2:Thread-1
id of t1:8
running...

Thread priority
Each thread have a priority. Priorities are represented by a
number between 1 and 10. In most cases, thread schedular
schedules the threads according to their priority (known as
preemptive scheduling). But it is not guaranteed because it
depends on JVM specification that which scheduling it
chooses

3 constants defiend in Thread class:
1. public static int MIN_PRIORITY
2. public static int NORM_PRIORITY
3. public static int MAX_PRIORITY
Default priority of a thread is 5 (NORM_PRIORITY). The
value of MIN_PRIORITY is 1 and the value of
MAX_PRIORITY is 10.

Example of priority of a Thread:

 class TestMultiPriority1 extends Thread{
public void run(){
   System.out.println("running thread name is:"+Thread.currentThread().getName());
   System.out.println("running thread priority is:"+Thread.currentThread().getPriority());
  }
  TestMultiPriority1 m1=new TestMultiPriority1();
  TestMultiPriority1 m2=new TestMultiPriority1();
  m1.setPriority(Thread.MIN_PRIORITY);
  m2.setPriority(Thread.MAX_PRIORITY);
  m1.start();
  m2.start();
}
}

Output:
running thread name is:Thread-0
running thread priority is:10
running thread name is:Thread-1
running thread priority is:1

Thread synchronization
When two or more threads need access to a shared resource,
they need some way to ensure that the resource will be used by
only one thread at a time. The process by which the thread is
achieved is called synchronization.
The keyword synchronized helps to solve such problems by
keeping a watch on such locations. For example, the method that
will read information from a file and the method that will update
the same file may be declared as synchronized.

Why use Synchronization
The synchronization is mainly used to
1. To prevent thread interference.
2. To prevent consistency problem

Thread Synchronization
There are two types of thread synchronization mutual
exclusive and inter-thread communication.
Mutual Exclusive
Synchronized method.
Synchronized block.
static synchronization.
Cooperation (Inter-thread communication in java)

Mutual Exclusive
Mutual Exclusive helps keep threads from interfering with
one another while sharing data. This can be done by three
ways in java:
1. by synchronized method
2. by synchronized block
3. by static synchronization

synchronized void update()
{
…………….
……………. // code here is synchronized
…………….
}
when we declare a method synchronized, java creates a
“monitor” and hands it over to the thread that calls the method
first time. As long as the thread holds the monitor, no other
thread can enter the synchronized section of code. A monitor is
like a key and the thread that holds the key can only open the
lock.

It is also possible to mark a block of code as synchronized as
shown below:
synchronized (lock-object)
{
………………..
………………. // code here is synchronized
}
Whenever a thread has completed its work of using synchronized
method (or block of code), it will hand over the monitor to the
next thread that is ready to use the same resource.

An interesting situation may occur when two or more threads are
waiting to gain control of a resource. Due to some reasons, the
condition on which the waiting threads rely on to gain control does not
happen. This result in what is known as deadlock. For example, assume
that the thread A must access Method1 before it can release
Method2. because these are mutually exclusive conditions, a deadlock
occurs. The code below illustrate this.
 Thread A
synchronized method2()
{
{
………………..
………………..
}
}

Thread B
{
{
………………..
………………..
}
}

Deadlock in java
Deadlock in java is a part of multithreading. Deadlock can
occur in a situation when a thread is waiting for an object
lock, that is acquired by another thread and second thread is
waiting for an object lock that is acquired by first thread.
Since, both threads are waiting for each other to release the
lock, the condition is called deadlock

Inter-thread communication in Java
Inter-thread communication or Co-operation is all
about allowing synchronized threads to communicate with
each other.
Cooperation (Inter-thread communication) is a mechanism
in which a thread is paused running in its critical section and
another thread is allowed to enter (or lock) in the same
critical section to be executed.It is implemented by
following methods of Object class:
1. wait()
2. notify()
3. notifyAll()

1) wait() method
Causes current thread to release the lock and wait until
either another thread invokes the notify() method or the
notifyAll() method for this object, or a specified amount of
time has elapsed.
The current thread must own this object's monitor, so it
must be called from the synchronized method only otherwise
it will throw exception.

Method Description
public final void
wait()throws
public final void wait(long
timeout)throws
waits until object is
notified
waits for the specified
amount of time

2) notify() method
Wakes up a single thread that is waiting on this object's
monitor. If any threads are waiting on this object, one of
them is chosen to be awakened. The choice is arbitrary and
occurs at the discretion of the implementation. Syntax:
public final void notify()

3) notifyAll() method
Wakes up all threads that are waiting on this object's
monitor. Syntax:
public final void notifyAll()

Basic of Multithreading in JAva

More Related Content

What's hot (20)

Similar to Basic of Multithreading in JAva (20)

More from suraj pandey (20)

Recently uploaded (20)

Basic of Multithreading in JAva