Assertions, Multithreading: Introduction, differences, Thread life cycle, Creation

of threads, Thread priorities, Thread Synchronization, Communication Between

Threads.

1. Thread Introduction
2. Difference between Multiprocessing and Multithreading
3. Thread Life cycle(The States of the Thread)
 Thread Introduction

A thread in a Java program runs asynchronously. A program can be divided into a

number of small processes. Each small process can be addressed as a single
thread (a lightweight process). Multithreaded programs contain two or more
threads that can run concurrently and each thread defines a separate path of
execution. This means that a single program can perform two or more tasks
simultaneously. For example, one thread is writing content on a file at the same
time another thread is performing spelling check.

In Java, the word thread means two different things.

 An instance of Thread class./ or, A thread of execution.

An instance of Thread class is just an object, like any other object in java. But a
thread of execution means an individual "lightweight" process that has its own
call stack. In java each thread has its own call stack.
 Difference between Multiprocessing and Multithreading

There are two distinct types of multitasking: Process-based and Thread-based.

The Program in execution is defined as Process. Thus, the process based multi
tasking is the feature that allows your computer to run two or more programs
concurrently. For example we are able to use the java compiler and text editor at
the same time. Another example is, we are able to hear the music and also able to
get the print outs from the printer.

Process-Based Multitasking Thread-Based Multitasking

This deals with "Big Picture" This deals with Details
These are Heavyweight tasks These are Lightweight tasks

Inter-process communication is Inter-Thread communication is

expensive and limited inexpensive.
Context switching from one process to Context switching is low cost in terms of
another is costly in terms of memory. memory, because they run on the same
address space.
This is not under control of java.
Controlled by java.
 Thread Life cycle(The States of the Thread)

A thread can be in one of the several states. In general terms, a thread can
running. It can be ready to run as soon as it gets the CPU time. A running thread
can be suspended, which is a temporary halt to its execution. It can later be
resumed. A thread can be blocked when waiting for the resource. A thread can
be terminated.

New State: When we create a thread it is said to be in the new born state. At
this state we can schedule it for running using the start() method or to Kill it
using stop() method.
Runnable State: A runnable state means that a thread is ready for execution
and waiting for the availability of the processor. That is the thread has joined
the queue of the threads for execution. If all the threads have equal priority,
then they are given time slots for execution in the round rabin fashion, first-
come, first-serve manner.

Running state: Running state means that the processor has given its time to the
thread for it execution. The thread runs until it relinquishes the control or it is
preempted by the other higher priority thread. A running thread can be
preempted using the suspen(), or wait(), or sleep() methods.
Blocked state: A thread is said to be in the blocked state when it is prevented
from entering into runnable state and subsequently the running state.

terminated state: Every thread has a life cycle. A running thread ends its life
when it has completed execution. It is a natural death. However we also can kill
the thread by sending the stop() message to it at any time.

Thread methods

Sl No Method Name Description

1 run() Used to write the body of the thread

2 start() Used to start the thread

3 sleep() Used to make the thread sleep for milliseconds
4 suspend() Used to suspend a running thread
5 wait() Waits until further ordered
6 Yield Used to give control to other thread before it turn comes
7 Stop() Used to stop the thread
8 resume() Used to start the blocked thread
9 notify() Used to notify the waiting thread
10 notifyAll() Used to notify theall waiting threads
 The main thread is created automatically when program is started, it can be
controlled through a Thread object. To do so, you must obtain a reference to it
by calling the method currentThread( ), which is a public static member of
Thread.

//Controlling the main Thread. Output :

5
4
class one 3
{ 2
public static void main(String args[]) 1
{
Thread t = Thread.currentThread();
System.out.println("Current thread: " + t);
t.setName("My Thread");
System.out.println("After name change: " + t);

try
{
for(int n=5;n>0;n--)
{
System.out.println(n);
Thread.sleep(1000);
}}
catch (InterruptedException e)
{
System.out.println("Main thread interrupted");
}}}
Creation of Thread

Creating the threads in the Java is simple. The threads can be implemented
in the form of object that contains a method "run()". The "run()" method is the
heart and soul of any thread. It makes up the entire body of the thread and is the
only method in which the thread behavior can be implemented. There are two
ways to create thread.

1. Declare a class that implements the Runnable interface which

contains the run() method .
2. Declare a class that extends the Thread class and override the run()
method.

1. Implementing the Runnable Interface

The Runnable interface contains the run() method that is required for
implementing the threads in our program. To do this we must perform the
following steps:

I. Declare a class as implementing the Runnable interface

II. Implement the run() method
III. Create a Thread by defining an object that is instantiated from this
"runnable" class as the target
of the thread
IV. Call the thread's start() method to run the thread.
// example 1 class one
import java.io.*; {
import java.util.Scanner; public static void main(String[]args)
{
class xyz implements Runnable xyz x=new xyz();
{ Thread t=new Thread(x);
public void run() t.start();
{ }
System.out.println("Java Thread }
Example");
}
}
// Example 2 class one
import java.io.*; {
import java.util.Scanner; public static void main(String[]args)
{
class xyz implements Runnable xyz x=new xyz();
{ Thread t=new Thread(x);
public void run() t.start();
{ }
try }
{
for(int i=0;i<=3;i++)
{
Thread.sleep(1000);
System.out.println("Value of i=:"+i);
}
System.out.println("End Block");
}
catch(InterruptedException e)
{
System.out.println(e);
}}}

// Example 3 class one

import java.io.*; {
import java.util.Scanner; public static void main(String[]args)
{
class xyz implements Runnable xyz x=new xyz();
{ Thread t=new Thread(x);
public void run() t.start();
{ }
System.out.println("Method Calling }
Example");
sample();
}
void sample()
{
System.out.println("Sample Method");
}
}
// example 4 class one
{
import java.io.*; public static void main(String[]args)
import java.util.Scanner; {
xyz x=new xyz();
class xyz implements Runnable abc a=new abc();
{ Thread t=new Thread(x);
public void run() Thread tt=new Thread(a);
{ t.start();
try tt.start();
{ }
for(int i=0;i<=3;i++) }
{
Thread.sleep(1000);
System.out.println("Value of i=:"+i);
}
System.out.println("I Block Ended");
}
catch(InterruptedException e)
{
System.out.println(e);
}
}
}
class abc implements Runnable
{
public void run()
{
try
{
for(int j=0;j<=3;j++)
{
Thread.sleep(1000);
System.out.println("Value of j=:"+j);
}
System.out.println("j Block Ended");
}
catch(InterruptedException e)
{
System.out.println(e);
}
}
}
final void join( ) throws InterruptedException : This method waits until the thread on which it
is called terminates.

//Example 5 class one

import java.io.*; {
import java.util.Scanner; public static void main(String[]args)
{
class xyz implements Runnable xyz x=new xyz();
{ abc a=new abc();
public void run() Thread t=new Thread(x);
{ Thread tt=new Thread(a);
try try
{ {
for(int i=0;i<=3;i++) t.start();
{ t.join();
Thread.sleep(1000); tt.start();
System.out.println("Value of i=:"+i);
} }
System.out.println("I Block Ended"); catch(InterruptedException e)
} {
catch(InterruptedException e) System.out.println(e);
{ }
System.out.println(e); }
} }
}
}
class abc implements Runnable
{
public void run()
{
try
{
for(int j=0;j<=3;j++)
{
Thread.sleep(1000);
System.out.println("Value of j=:"+j);
}
System.out.println("j Block Ended");
}
catch(InterruptedException e)
{
System.out.println(e);
}
}
}
2. Extending the thread class

We can make our thread by extending the Thread class of

java.lang.Thread class. This gives us access to all the methods of the Thread. It
includes the following steps:

I. Declare the class as Extending the Thread class.

II. Override the "run()" method that is responsible for running the thread.
III. Create a thread and call the "start()" method to instantiate the Thread
Execution.
Declaring the class Overriding the method run()
The run() is the method of the Thread.
TheThread class can be declared as We can override this as follows:
follows: class MyThread extends Thread public void run()
{ {
----------------------- ----------------
---------------------- ----------------
} }

Starting the new Thread :

MyThread a=new MyThread(); // creating the Thread
a.start(); // Starting the Thread
// Example 1 catch(InterruptedException e)
import java.io.*; {
import java.util.Scanner; System.out.println(e);
}}}
class A extends Thread
{
public void run() class one
{ {
try public static void main(String[]args)
{ {
for(int i=0;i<=3;i++) A AA=new A();
{ AA.start();
System.out.println("I Value :"+i); }
Thread.sleep(1000); }
}}
// example 2 class B extends Thread
import java.io.*; {
import java.util.Scanner; public void run()
{
class A extends Thread try
{ {
public void run() for(int j=0;j<=3;j++)
{ {
try System.out.println("j Value :"+j);
{ Thread.sleep(1000);
for(int i=0;i<=3;i++) }
{ }
System.out.println("I Value :"+i); catch(InterruptedException e)
Thread.sleep(1000); {
} System.out.println(e);
} }}}
catch(InterruptedException e)
{
System.out.println(e); class one
}}} {
public static void main(String[]args)
{
try
{
A AA=new A();
B BB=new B();
AA.start();
AA.join();
BB.start();
}
catch(InterruptedException e)
{
System.out.println(e);
}}}
// example 3 class C implements Runnable
import java.io.*; {
import java.util.Scanner; public void run()
{
class A B bb=new B();
{ bb.test1();
void test1() bb.test2();
{ }
System.out.println("one"); }
}
}
class one
class B extends A {
{ public static void main(String[]args)
void test2() {
{ C cc=new C();
System.out.println("two"); Thread t=new Thread(cc);
} t.start();
} }
}

// example 4 class B extends A implements B1

import java.io.*; {
import java.util.Scanner; public void test2()
{
test1();
interface A1 System.out.println("two");
{ }
void test1(); }
}
class C extends Thread
class A implements A1 {
{ public void run()
public void test1() {
{ B bb=new B();
System.out.println("one"); bb.test2();
} }
} }
interface B1
{ class one
void test2(); {
} public static void main(String[]args)
{
C cc=new C();
cc.start();}}
sleep( ) method
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:
o public static void sleep(long miliseconds)throws InterruptedException

import java.io.*;
import java.util.Scanner; public static void main(String[]args)
{
class one extends Thread one o=new one();
{ one oo=new one();
public void run()
{
try try
{ {
for(int i=0;i<=3;i++) o.start();
{ o.join();
System.out.println("Value of i=:"+i); //o.start();
Thread.sleep(1000); oo.start();
} }
} catch(InterruptedException e)
catch(InterruptedException e) {
{ System.out.println(e);
System.out.println(e); }}}
}}
Creating Multiple Threads

import java.io.*; public void run()

{
class xyz implements Runnable try
{ {
String str1; for(int i=0;i<=3;i++)
Thread t; {
xyz(String str2) System.out.println("Name :"+i);
{ Thread.sleep(1000);
try }}
{ catch(InterruptedException e)
str1=str2; {
t=new Thread(this,str1); System.out.println(e);
System.out.println("New Thread=:"+t); } }}
t.start(); class one
t.join(); {
} public static void main(String[]args)
catch(InterruptedException e) {
{ //xyz x=new xyz("one");
System.out.println(e); //xyz y=new xyz("two");
} new xyz("one");
} new xyz("two");
System.out.println("End of Thread");
}}
final boolean isAlive(); This method returns the either "TRUE" or "FALSE" . It
returns "TRUE" if the thread is alive, returns "FALSE" otherwise.

// isAlive() example public void run()

{
import java.io.*; try
{
class xyz implements Runnable for(int i=0;i<=2;i++)
{ {
String str1; System.out.println(i);
Thread t; Thread.sleep(1000);
xyz(String str2) }
{ }
try catch(InterruptedException e)
{ {
str1=str2; System.out.println(e);
t=new Thread(this,str1); }
}
t.start(); }
System.out.println(t.isAlive());
t.join();
System.out.println(t.isAlive());
} class one
catch(InterruptedException e) {
{ public static void main(String[]args)
System.out.println(e); {
} new xyz("one");
} new xyz("two");
}
}
The Thread Priorities: Thread priorities are used by the thread scheduler to decide
when and which thread should be allowed to run. In theory, higher-priority
threads get more CPU time than lower-priority threads. To set a thread’s priority,
use the setPriority( ) method, which is a member of Thread.

final void setPriority(int level)

final int getPriority( )

// example 1 class one

{
class PThread1 extends Thread public static void main(String args[])
{ {
public void run()
{ PThread1 pt1=new PThread1();
System.out.println(" Child 1 is started");
} pt1.setPriority(1);
} PThread2 pt2=new PThread2();
class PThread2 extends Thread pt2.setPriority(9);
{ PThread3 pt3=new PThread3();
public void run() pt3.setPriority(6);
{ pt1.start();
System.out.println(" Child 2 is started"); pt2.start();
} pt3.start();
}
class PThread3 extends Thread System.out.println("The pt1 thread
{ priority is :"+pt1.getPriority());
public void run() }
{ }
System.out.println(" Child 3 is started");
}
}
1. public static int MIN_PRIORITY: It is the maximum priority of a thread. The
value of it is 1.
2. public static int NORM_PRIORITY: It is the normal priority of a thread. The
value of it is 5.
3. public static int MAX_PRIORITY: It is the minimum priority of a thread. The
value of it is 10.

// example 2
class one
class A extends Thread {
{ public static void main(String[]args)
public void run() {
{
System.out.println(Thread.currentThr try
ead().getPriority()); {
System.out.println("Thread A"); A AA=new A();
} AA.setPriority(Thread.MIN_PRIORITY);
} B BB=new B();
BB.setPriority(Thread.MAX_PRIORITY);
class B extends Thread C CC=new C();
{ CC.setPriority(Thread.NORM_PRIORITY
public void run() );
{ AA.start();
System.out.println(Thread.currentThr AA.join();
ead().getPriority()); BB.start();
System.out.println("Thread B"); BB.join();
} CC.start();
} }
catch(InterruptedException e)
class C extends Thread {
{ System.out.println(e);
public void run() }}}
{
System.out.println(Thread.currentThr
ead().getPriority());
System.out.println("Thread C");
}}
// Another Example public void run()
import java.io.*; {
class xyz implements Runnable try
{ {
String str1; for(int i=0;i<=3;i++)
Thread t; {
xyz(String str2) System.out.println("Value of
{ i=:"+i);
try Thread.sleep(1000);
{ }}
str1=str2; catch(InterruptedException e)
t=new Thread(this,str1); {
t.start(); System.out.println(e);
t.setPriority(Thread.MAX_PRIORITY); }
System.out.println(t.isAlive()); }
t.join(); }
System.out.println("Thread=:"+t.getName());
System.out.println(t.getPriority());
System.out.println(t.getId());
System.out.println("Thread Completed"); class one
System.out.println("Thread Position {
:"+t.isAlive()); public static void main(String
Thread.sleep(1000);} []args)
catch(InterruptedException e) {
{ xyz xx=new xyz("aa");
System.out.println(e); xyz xxx=new xyz("bbb");
}} }}
 Synchronization

When two or more threads need access to a shared resource, they need
to ensure that the resource will be used by only one thread at a time. The
process by which this is achieved is called synchronization
//without the synchronization class MyThread2 extends Thread
class Table {
{ Table t;
void printTable(int n)
{ MyThread2(Table t)
for(int i=1;i<=5;i++) {
{ this.t=t;
System.out.println(n*i); }
try
{ public void run()
Thread.sleep(400); {
} t.printTable(100);
}
catch(InterruptedException ie) }
{
System.out.println("The Exception is
:"+ie);
}}}} class one
class MyThread1 extends Thread {
{ public static void main(String args[])
Table t; {
MyThread1(Table t) Table obj = new Table();
{ MyThread1 t1=new MyThread1(obj);
this.t=t; MyThread2 t2=new MyThread2(obj);
} t1.start();
public void run() t2.start();
{ }
t.printTable(5); }
}}
 Using the Java synchronized method

Synchronized method is used to lock an object for any shared resource. When
a thread invokes a synchronized method, it automatically acquires the lock for
that object and releases it when the thread completes its task. The general
form of the synchronized method is:
Syntax : synchronized type method_name(para_list)
{
//body of the method
}
// Using the Java synchronized public void run()
method {
t.printTable(5);
class Table }}
{ class MyThread2 extends Thread
synchronized void printTable(int n) {
{ Table t;
for(int i=1;i<=5;i++) MyThread2(Table t)
{ {
System.out.println(n*i); this.t=t;
try }
{ public void run()
Thread.sleep(400); } {
catch(InterruptedException ie) t.printTable(100);
{ }}
System.out.println("The Exception is class one
:"+ie); {
}}}} public static void main(String args[])
class MyThread1 extends Thread {
{ Table obj = new Table();
Table t; MyThread1 t1=new MyThread1(obj);
MyThread1(Table t) MyThread2 t2=new MyThread2(obj);
{ t1.start();
this.t=t; t2.start();
} }}
 Note:

1. This way of communications between the threads competing for same

resource is called implicit communication.
2. This has one disadvantage due to polling. The polling wastes the CPU
time. To save the CPU time, it is preferred to go to the inter-thread
communication.

Inter-Thread Communication

If two or more Threads are communicating with each other, it is called "inter
thread" communication. Using the synchronized method, two or more threads
can communicate indirectly. Through, synchronized method, each thread always
competes for the resource. This way of competing is called polling. The polling
wastes the much of the CPU valuable time. The better solution to this problem is,
just notify other threads for the resource, when the current thread has finished its
task. This is explicit communication between the threads.

Java addresses this polling problem, using via wait(), notify(), and notifyAll()
methods. These methods are implemented as final methods in Object, so all
classes have them. All three methods can be called only from within a
synchronized context.

wait( ) : It tells the calling thread to give up the lock and go to sleep until some
other thread enters the same monitor and calls notify(). The wait() method
releases the lock prior to waiting and reacquires the lock prior to returning from
the wait() method. The wait() method is actually tightly integrated with the
synchronization lock, using a feature not available directly from the
synchronization mechanism.
 synchronized( lockObject )
{
while( ! condition )
{
lockObject.wait();
}

//take the action here; }

Notify : It wakes up one single thread that called wait() on the same object. It
should be noted that calling notify() does not actually give up a lock on a
resource. It tells a waiting thread that that thread can wake up. However, the lock
is not actually given up until the notifier’s synchronized block has completed.

synchronized(lockObject)
{
//establish_the_condition;

lockObject.notify();

//any additional code if needed

}

notifyAll : It wakes up all the threads that called wait() on the same object. The
highest priority thread will run first in most of the situation, though not
guaranteed. Other things are same as notify() method above.

synchronized(lockObject)
{
establish_the_condition;

lockObject.notifyAll();
}
//Diff.between lock Vs Sleep public static void main(String []args)
// example 1 {
class one one o=new one();
{ try
Object LOCK = new Object(); {
void sleepWaitExamples() throws o.sleepWaitExamples() ;
InterruptedException }
{ catch(InterruptedException e)
Thread.sleep(1000); {
System.out.println("Thread '" + System.out.println(e);
Thread.currentThread().getName() +"' }
is woken after }
}
sleeping for 1 second");

synchronized (LOCK)
{
LOCK.wait(1000);
System.out.println("Object '" + LOCK +
"' is woken after" + " waiting for 1
second");
}}

// another example2 LOCK.wait(1000);

import java.io.*; System.out.println(i);
}
class xyz extends Thread catch(InterruptedException e)
{ {
Object LOCK = new Object(); System.out.println(e);
public void run() }}}}}
{ class one
synchronized(LOCK) {
{ public static void main(String[]args)
for(int i=1;i<=3;i++) throws InterruptedException
{ {
try xyz x=new xyz();
{ x.start();}}
// Example 3 class one
class table {
{ public static void main(String []args)
synchronized void mathtable(int x) {
{ table tt=new table();
for(int i=1;i<=3;i++) xyz x=new xyz(tt);
{ xyz xx=new xyz(tt);
try
{ try
wait(1000); {
System.out.println(x*i); x.start();
} Thread.sleep(1000);
catch(InterruptedException e) x.join();
{ xx.start();
System.out.println(e); }
}}}} catch(InterruptedException e)
{
class xyz extends Thread System.out.println(e);
{ }
table t;
xyz(table t) }
{ }
this.t=t;
}

public void run()

{
t.mathtable(5);
}}
// wait,notify,notifyAll examples class one
{
import java.io.*; public static void main(String[]args)
{
class xyz xyz x=new xyz();
{
synchronized void waitmethod() Thread t1=new Thread()
{ {
Thread t=Thread.currentThread(); public void run()
System.out.println(t.getName() + "is {
releasing the lock and going to wait"); x.waitmethod();
try }};
{ t1.start();
wait(1000);
} Thread t2=new Thread()
catch(InterruptedException e) {
{ public void run()
System.out.println(e); {
} x.waitmethod();
System.out.println("has been notified }};
and acquired the lock back"); t2.start();
}
Thread t3=new Thread()
synchronized void notifyonemethod() {
{ public void run()
Thread t=Thread.currentThread(); {
notifyAll(); x.waitmethod();
System.out.println(t.getName()+"has }};
notified one thread waiting for this t3.start();
object lock");
}} try
{
Thread.sleep(1000);
}
catch(InterruptedException e)
{
System.out.println(e);
}
Thread t4=new Thread()
{
public void run()
{
x.notifyonemethod();
}};
t4.start();}}
Suspending, Blocking and Stopping Threads : Whenever we want stop a thread
we can stop from running using "stop()" method of thread class. It's general form
will be as follows:

Thread.stop();
This method causes a thread to move from running to dead state. A
thread will also move to dead state automatically when it reaches the end of
its method. Blocking Thread . A thread can be temporarily suspended or
blocked from entering into the runnable and running state by using the
following methods:

sleep() —blocked for specified time

suspend() ----blocked until further orders

wait() --blocked until certain condition occurs

These methods cause the thread to go into the blocked state. The thread
will return to the runnable state when the specified time is elapsed in the case of
sleep(), the resume() method is invoked in the case of suspend(), and the notify()
method is called in the case of wait().

class NewThread implements Runnable class one

{ {
String name; public static void main(String args[])
Thread t; {
NewThread(String threadname) NewThread ob1 = new
{ NewThread("One");
name = threadname; NewThread ob2 = new
t = new Thread(this, name); NewThread("Two");
System.out.println("New thread: " + t); try
t.start(); {
} Thread.sleep(1000);
ob1.t.suspend();
public void run() System.out.println("Suspending thread
{ One");
try Thread.sleep (1000);
{ ob1.t.resume();
for(int i = 15; i > 0; i--) System.out.println("Resuming thread
{ One");
System.out.println(name + ": " + i); ob2.t.suspend();
Thread.sleep(200); System.out.println("Suspending thread
} Two");
} Thread.sleep(1000);
catch (InterruptedException e) ob2.t.resume();
{ System.out.println("Resuming thread
System.out.println(name + " Two");
interrupted."); }
} catch (InterruptedException e)
System.out.println(name + " exiting."); {
} System.out.println("Main thread
} Interrupted");
}
try
{
System.out.println("Waiting for threads
to finish.");
ob1.t.join();
ob2.t.join();
}
catch (InterruptedException e)
{
System.out.println("Main thread
Interrupted");
}
System.out.println("Main thread
exiting.");
}}

Thread Exceptions
Note that a call to the sleep() method is always enclosed in try/ catch block.
This is necessary because the sleep() method throws an exception, which
should be caught. If we fail to catch the exception the program will not compile.
try
{
Thread.sleep(1000); }
cathc(Exception e)
{
--------
}