Iot Oops Chap 3

IOT OOPS USING JAVA CHAP 3
Q) Explain about Exception Handling in Java

7 marks
Answer)
The exception handling in java is one of the powerful mechanism to handle the runtime
errors so that normal flow of the application can be maintained.
In this page, we will learn about java exception, its type and the difference between checked
and unchecked exceptions.
What is exception
Dictionary Meaning: Exception is an abnormal condition.
In java, exception is an event that disrupts the normal flow of the program. It is an object
which is thrown at runtime.
What is exception handling

Exception Handling is a mechanism to handle runtime errors such as ClassNotFound, IO, SQL,
Remote etc.
Advantage of Exception Handling
The core advantage of exception handling is to maintain the normal flow of the application.
Exception normally disrupts the normal flow of the application that is why we use exception
handling. Let's take a scenario:
1. statement 1;
2. statement 2;
3. statement 3;
4. statement 4;
5. statement 5;//exception occurs
6. statement 6;
7. statement 7;
8. statement 8;
9. statement 9;
10. statement 10;
Suppose there is 10 statements in your program and there occurs an exception at statement
5, rest of the code will not be executed i.e. statement 6 to 10 will not run. If we perform
exception handling, rest of the statement will be executed. That is why we use exception
handling in java.
Types of Exception
There are mainly two types of exceptions: checked and unchecked where error is
considered as unchecked exception. The sun microsystem says there are three types
of exceptions:
1. Checked Exception
2. Unchecked Exception
3. Error
Difference between checked and

unchecked exceptions
1) Checked Exception
The classes that extend Throwable class except RuntimeException and Error are
known as checked exceptions e.g.IOException, SQLException etc. Checked
exceptions are checked at compile-time.
2) Unchecked Exception
The classes that extend RuntimeException are known as unchecked exceptions e.g.
ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException etc.
Unchecked exceptions are not checked at compile-time rather they are checked at
runtime.
3) Error
Error is irrecoverable e.g. OutOfMemoryError, VirtualMachineError, AssertionError
etc.
Common scenarios where exceptions may

occur
There are given some scenarios where unchecked exceptions can occur. They are
as follows:
1) Scenario where ArithmeticException occurs
If we divide any number by zero, there occurs an ArithmeticException.
1. int a=50/0;//ArithmeticException
2) Scenario where NullPointerException occurs

If we have null value in any variable, performing any operation by the variable
occurs an NullPointerException.
1. String s=null;
2. System.out.println(s.length());//NullPointerException
3) Scenario where NumberFormatException occurs

The wrong formatting of any value, may occur NumberFormatException. Suppose I
have a string variable that have characters, converting this variable into digit will
occur NumberFormatException.
1. String s="abc";
2. int i=Integer.parseInt(s);//NumberFormatException
4) Scenario where
ArrayIndexOutOfBoundsException occurs
If you are inserting any value in the wrong index, it would result
ArrayIndexOutOfBoundsException as shown below:
1. int a[]=new int[5];
2. a[10]=50; //ArrayIndexOutOfBoundsException
Java Exception Handling Keywords

There are 5 keywords used in java exception handling.
1)try
2)catch
3)finally
4)throw
5) throws
Java try block

Java try block is used to enclose the code that might throw an exception. It must be
used within the method.
Java try block must be followed by either catch or finally block.
Syntax of java try-catch
try{
//code that may throw exception
}catch(Exception_class_Name ref){}
Syntax of try-finally block
try{
//code that may throw exception
}finally{}
Java catch block
Java catch block is used to handle the Exception. It must be used after the try block
only.
You can use multiple catch block with a single try.
Problem without exception handling

Let's try to understand the problem if we don't use try-catch block.
1. public class Testtrycatch1{
2. public static void main(String args[]){
3. int data=50/0;//may throw exception
4. System.out.println("rest of the code...");
5. }
6. }
Test it Now
Output:
Exception in thread main java.lang.ArithmeticException:/ by zero
As displayed in the above example, rest of the code is not executed (in such case,
rest of the code... statement is not printed).
There can be 100 lines of code after exception. So all the code after exception will
not be executed.
Solution by exception handling

Let's see the solution of above problem by java try-catch block.
1. public class Testtrycatch2{
3. try{
4. int data=50/0;
5. }catch(ArithmeticException e){System.out.println(e);}
7. }
8. }
Test it Now
Output:
rest of the code...
Now, as displayed in the above example, rest of the code is executed i.e. rest of the
code... statement is printed.
The JVM firstly checks whether the exception is handled or not. If exception is not
handled, JVM provides a default exception handler that performs the following
tasks:
o Prints out exception description.
o Prints the stack trace (Hierarchy of methods where the exception occurred).
o Causes the program to terminate.
But if exception is handled by the application programmer, normal flow of the
application is maintained i.e. rest of the code is executed.
Java finally block
Java finally block is a block that is used to execute important

code such as closing connection, stream etc.
Java finally block is always executed whether exception is handled or not.
Java finally block follows try or catch block.
Note: If you don't handle exception, before terminating the program, JVM executes
finally block(if any).
Why use java finally

o Finally block in java can be used to put "cleanup" code such as closing a file,
closing connection etc.
Usage of Java finally

Let's see the different cases where java finally block can be used.
Case 1
Let's see the java finally example where exception doesn't occur.
1. class TestFinallyBlock{
3. try{
4. int data=25/5;
5. System.out.println(data);
6. }
7. catch(NullPointerException e){System.out.println(e);}
8. finally{System.out.println("finally block is always executed");}
10. }
11. }
Output:5
finally block is always executed
rest of the code...
Case 2
Let's see the java finally example where exception occurs and not handled.
1. class TestFinallyBlock1{
3. try{
4. int data=25/0;
6. }
7. catch(NullPointerException e){System.out.println(e);}
10. }
11. }
Output:finally block is always executed
Case 3
Let's see the java finally example where exception occurs and handled.
1. public class TestFinallyBlock2{
3. try{
4. int data=25/0;
6. }
7. catch(ArithmeticException e){System.out.println(e);}
10. }
11. }
Test it Now
Output:Exception in thread main java.lang.ArithmeticException:/ by zero
finally block is always executed
rest of the code...
Rule: For each try block there can be zero or more catch blocks, but
only one finally block.
Note: The finally block will not be executed if program exits(either by
calling System.exit() or by causing a fatal error that causes the
process to abort).
Multiple catch()
1. public class multipleCatch {
2.
3. public static void main(String[] args) {
4.
5. try {
6. int list[] = new int[5];
7. list[2] = 10;
8. list[4] = 2;
9. list[10] = list[2] / list[4];
10. }
11. catch(ArithmeticException ae) {
12. System.out.println("Problem info: Value of divisor can not
be ZERO.");
13. }
14. catch(ArrayIndexOutOfBoundsException aie) {
15. System.out.println("Probleminfo:
ArrayIndexOutOfBoundsException has occured.");
16. }
17. catch(Exception e) {
18. System.out.println("Problem info: Unknown exception has
occured.");
19. }
20. }
21. }
Throw
import java.util.Scanner;
public class throwExample {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int num1, num2, result;
System.out.print("Enter any two numbers: ");
num1 = input.nextInt();
try {
if(num2 == 0)
throw new ArithmeticException("Division by zero is not
posible");
result = num1 / num2;
System.out.println(num1 + "/" + num2 + "=" + result);
}
catch(ArithmeticException ae) {
System.out.println("Problem info: " + ae.getMessage());
}
System.out.println("End of the program");
}
}
Throws
public class Main {
static void checkAge(int age) throws ArithmeticException {
if (age < 18) {
throw new ArithmeticException("Access denied - You must be at
least 18 years old.");
}
else {
System.out.println("Access granted - You are old enough!");
}
}

checkAge(35); // Set age to 15 (which is below 18...)
}
}
java throw keyword example

In this example, we have created the validate method that takes integer value as a
parameter. If the age is less than 18, we are throwing the ArithmeticException
otherwise print a message welcome to vote.
1. public class TestThrow1{
2. static void validate(int age){
3. if(age<18)
4. throw new ArithmeticException("not valid");
5. else
6. System.out.println("welcome to vote");
7. }
9. validate(13);
11. }
12. }
Output:
Exception in thread main java.lang.ArithmeticException:not valid
Example for Built-in methods

class MultipleCatchBlock5{
public static void main(String args[]){
try{
int a[]=new int[5];
a[5]=30/0;
}
catch(Exception e){
System.out.println(e.toString());
System.out.println("\n rest of the code12...\n");
e.printStackTrace();
System.out.println(e.getMessage());
}
}
}
Output:
java.lang.ArithmeticException: / by zero
rest of the code12...
at MultipleCatchBlock5.main(MultipleCatchBlock5.java:5)
/ by zero
Example for Nested try

public class MultipleCatchBlock1 {
try{
try{
String name="Fasi";
int b = Integer.parseInt(name);
System.out.println(b);
}catch(Exception e)
{
System.out.println(e);
}
System.out.println("\trest of the code111");
int a[]=new int[5];

a[2]=30/0;
}
catch(Exception e2)
{
e2.printStackTrace();
}
System.out.println("rest of the code");

}
}
Output:
java.lang.NumberFormatException: For input string: "Fasi"
rest of the code111
at MultipleCatchBlock1.main(MultipleCatchBlock1.java:19)
rest of the code
Example for throw
public class TestThrow1{
static void validate(int age){
if(age<18)
throw new ArithmeticException("not valid");
else
System.out.println("welcome to vote\n");
}
public static void main(String args[]){
//try{
validate(2);
/* }
catch(Exception e)
{
e.printStackTrace();
}*/
System.out.println("\nrest of the code...");
}
}
Output:
Exception in thread "main" java.lang.ArithmeticException: not valid
at TestThrow1.validate(TestThrow1.java:4)
at TestThrow1.main(TestThrow1.java:10)
Output:
java.lang.ArithmeticException: not validat TestThrow1.validate(TestThrow1.java:4)
at TestThrow1.main(TestThrow1.java:10)
rest of the code...
Example for throws

public class ThrowsExample {
int num1, num2, result;

void division() throws ArithmeticException {

System.out.print("Enter any two numbers: ");
result = num1 / num2;
System.out.println(num1 + "/" + num2 + "=" + result);
}
ThrowsExample t1=new ThrowsExample();
try {
t1.division();
}
catch(ArithmeticException ae) {
System.out.println("Problem info: " + ae.getMessage());
}
System.out.println("End of the program");
}}
Example for User defined exception
class NotEligibleException extends Exception{

NotEligibleException(String msg){
super(msg);
}
}
class VoterList{
int age;
VoterList(int age){
this.age = age;
}
void checkEligibility() {
try {
if(age < 18) {
throw new NotEligibleException("Error: Not eligible for vote due to under age.");
}
System.out.println("Congrates! You are eligible for vote.");
}
catch(NotEligibleException nee) {
System.out.println(nee.getMessage());
}
}
public static void main(String args[]) {
System.out.println("Enter your age in years: ");
int age = input.nextInt();
VoterList person = new VoterList(age);
person.checkEligibility();
}
}
Output:
Enter your age in years:
33
Congrates! You are eligible for vote.
Output:
Enter your age in years:
16
Error: Not eligible for vote due to under age.
Q)What is multithreading? Explain with examples.

7 marks
Multithreading in Java
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.
However, we use multithreading than multiprocessing because 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.
Java Multithreading is mostly used in games, animation, etc.
Advantages of Java Multithreading

1) It doesn't block the user because threads are independent and you can perform multiple
operations at the 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 an exception occurs 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 in two ways:
o Process-based Multitasking (Multiprocessing)
o Thread-based Multitasking (Multithreading)
1) Process-based Multitasking (Multiprocessing)
o Each process has an address in memory. In other words, each process allocates a
separate memory area.
o A process is heavyweight.
o Cost of communication between the process is high.
o Switching from one process to another requires some time for saving and loading
registers, memory maps, updating lists, etc.
2) Thread-based Multitasking (Multithreading)
o Threads share the same address space.
o A thread is lightweight.
o Cost of communication between the thread is low.
Note: At least one process is required for each thread.
What is Thread in java

A thread is a lightweight subprocess, the 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 uses a shared memory area.
As shown in the above figure, a 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.
Note: At a time one thread is executed only.
Java Thread class

Java provides Thread class to achieve thread programming. Thread class provides
constructors and methods to create and perform operations on a thread. Thread class
extends Object class and implements Runnable interface.
Java Thread Methods

S.N. Modifier and Method Description
Type
1) void start() It is used to start the execution of the

thread.
2) void run() It is used to do an action for a thread.
3) static void sleep() It sleeps a thread for the specified

amount of time.
4) static Thread currentThread() It returns a reference to the currently

executing thread object.
5) void join() It waits for a thread to die.

6) int getPriority() It returns the priority of the thread.
7) void setPriority() It changes the priority of the thread.
8) String getName() It returns the name of the thread.
9) void setName() It changes the name of the thread.
10) long getId() It returns the id of the thread.
Life cycle of a Thread (Thread States)

1. Life cycle of a thread
1. New
2. Runnable
3. Running
4. Non-Runnable (Blocked)
5. Terminated
A thread can be in one of the five states. According to sun, there is only 4 states in thread life
cycle in java new, runnable, non-runnable and terminated. There is no running state.
But for better understanding the threads, we are explaining it in the 5 states.
The life cycle of the thread in java is controlled by JVM. The java thread states are as follows:
1. New
2. Runnable
3. Running
4. Non-Runnable (Blocked)
5. Terminated
1) New
The thread is in new state if you create an instance of Thread class but before the invocation
of start() method.
2) Runnable
The thread is in runnable state after invocation of start() method, but the thread scheduler
has not selected it to be the running thread.
3) Running
The thread is in running state if the thread scheduler has selected it.
4) Non-Runnable (Blocked)
This is the state when the thread is still alive, but is currently not eligible to run.
5) Terminated
A thread is in terminated or dead state when its run() method exits.
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 Constructors of Thread class:
o Thread()
o Thread(String name)
o Thread(Runnable r)
o Thread(Runnable r,String name)
Commonly used methods of Thread class:
1. public void run(): is used to perform action for a thread.
2. public void start(): starts the execution of the thread.JVM calls the run() method on the
thread.
3. public void sleep(long miliseconds): Causes the currently executing thread to sleep
(temporarily cease execution) for the specified number of milliseconds.
4. public void join(): waits for a thread to die.
5. public void join(long miliseconds): waits for a thread to die for the specified miliseconds.
6. public int getPriority(): returns the priority of the thread.
7. public int setPriority(int priority): changes the priority of the thread.
8. public String getName(): returns the name of the thread.
9. public void setName(String name): changes the name of the thread.
10. public Thread currentThread(): returns the reference of currently executing thread.
11. public int getId(): returns the id of the thread.
12. public Thread.State getState(): returns the state of the thread.
13. public boolean isAlive(): tests if the thread is alive.
14. public void yield(): causes the currently executing thread object to temporarily pause and
allow other threads to execute.
15. public void suspend(): is used to suspend the thread(depricated).
16. public void resume(): is used to resume the suspended thread(depricated).
17. public void stop(): is used to stop the thread(depricated).
18. public boolean isDaemon(): tests if the thread is a daemon thread.
19. public void setDaemon(boolean b): marks the thread as daemon or user thread.
20. public void interrupt(): interrupts the thread.
21. public boolean isInterrupted(): tests if the thread has been interrupted.
22. 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().
1. 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:
o A new thread starts(with new callstack).
o The thread moves from New state to the Runnable state.
o When the thread gets a chance to execute, its target run() method will run.
1) Java Thread Example by extending Thread class

1. class Multi extends Thread{
2. public void run(){
3. System.out.println("thread is running...");
4. }
6. Multi t1=new Multi();
7. t1.start();
8. }
9. }
Output:thread is running...
2) Java Thread Example by implementing Runnable interface

1. class Multi3 implements Runnable{
3. System.out.println("thread is running...");
4. }
5.
7. Multi3 m1=new Multi3();
8. Thread t1 =new Thread(m1);
9. t1.start();
10. }
11. }
Output:thread is running...
If you are not extending the Thread class,your class object would not be treated as a thread
object.So you need to explicitely create Thread class object.We are passing the object of your
class that implements Runnable so that your class run() method may execute.
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:
o public static void sleep(long miliseconds)throws InterruptedException
o public static void sleep(long miliseconds, int nanos)throws InterruptedException
Example of sleep method in java

1. class TestSleepMethod1 extends Thread{
3. for(int i=1;i<5;i++){
4. try{Thread.sleep(500);}catch(InterruptedException e){System.out.println(e);}
5. System.out.println(i);
6. }
7. }
9. TestSleepMethod1 t1=new TestSleepMethod1();
10. TestSleepMethod1 t2=new TestSleepMethod1();
11.
12. t1.start();
13. t2.start();
14. }
15. }
Output:
1
1
2
2
3
3
4
4
As you know well that at a time only one thread is executed. If you sleep a thread for the
specified time,the thread shedular picks up another thread and so on.
Can we start a thread twice

No. After starting a thread, it can never be started again. If you does so,
an IllegalThreadStateException is thrown. In such case, thread will run once but for second
time, it will throw exception.
Let's understand it by the example given below:
1. public class TestThreadTwice1 extends Thread{
3. System.out.println("running...");
4. }
6. TestThreadTwice1 t1=new TestThreadTwice1();
7. t1.start();
8. t1.start();
9. }
10. }
Test it Now
running
Exception in thread "main" java.lang.IllegalThreadStateException
What if we call run() method directly instead

start() method?
o Each thread starts in a separate call stack.
o Invoking the run() method from main thread, the run() method goes onto the current
call stack rather than at the beginning of a new call stack.
1. class TestCallRun1 extends Thread{
4. }
6. TestCallRun1 t1=new TestCallRun1();
7. t1.run();//fine, but does not start a separate call stack
8. }
9. }
Test it Now
Output:running...
Problem if you direct call run() method
1. class TestCallRun2 extends Thread{
3. for(int i=1;i<5;i++){
4. try{Thread.sleep(500);}catch(InterruptedException e){System.out.println(e);}
6. }
7. }
11.
12. t1.run();
13. t2.run();
14. }
15. }
Test it Now
Output:1
2
3
4
5
1
2
3
4
5
As you can see in the above program that there is no context-switching because here t1 and t2 will
be treated as normal object not thread object.
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 InterruptedException

Example of join() method
1. class TestJoinMethod1 extends Thread{
3. for(int i=1;i<=5;i++){
4. try{
5. Thread.sleep(500);
6. }catch(Exception e){System.out.println(e);}
8. }
9. }
11. TestJoinMethod1 t1=new TestJoinMethod1();
14. t1.start();
15. try{
16. t1.join();
18.
19. t2.start();
20. t3.start();
21. }
22. }
Test it Now
Output:1
2
3
4
5
1
1
2
2
3
3
4
4
5
5
As you can see in the above example,when t1 completes its task then t2 and t3 starts executing.
Example of join(long miliseconds) method
3. for(int i=1;i<=5;i++){
4. try{
8. }
9. }
14. t1.start();
15. try{
16. t1.join(1500);
18.
19. t2.start();
20. t3.start();
21. }
22. }
Test it Now
Output:1
2
3
1
4
1
2
5
2
3
3
4
4
5
5
In the above example,when t1 is completes its task for 1500 miliseconds(3 times) then t2 and
t3 starts executing.
getName(),setName(String) and getId() method:
public String getName()
public void setName(String name)
public long getId()

4. }
8. System.out.println("Name of t1:"+t1.getName());
10. System.out.println("id of t1:"+t1.getId());
11.
12. t1.start();
13. t2.start();
14.
15. t1.setName("Sonoo Jaiswal");
16. System.out.println("After changing name of t1:"+t1.getName());
17. }
18. }
Test it Now
Output:Name of t1:Thread-0
Name of t2:Thread-1
id of t1:8
running...
After changling name of t1:Sonoo Jaiswal
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
3. System.out.println(Thread.currentThread().getName());
4. }
5. }
9.
10. t1.start();
11. t2.start();
12. }
13. }
Test it Now
Output:Thread-0
Thread-1
next →← prev
Naming Thread and Current Thread

Naming Thread
The Thread class provides methods to change and get the name of a thread. By default,
each thread has a name i.e. thread-0, thread-1 and so on. By we can change the name
of the thread by using setName() method. The syntax of setName() and getName()
methods are given below:
1. public String getName(): is used to return the name of a thread.
2. public void setName(String name): is used to change the name of a thread.
Example of naming a thread
1. class TestMultiNaming1 extends Thread{
4. }
6. TestMultiNaming1 t1=new TestMultiNaming1();
10.
11. t1.start();
12. t2.start();
13.
14. t1.setName("Sonoo Jaiswal");
15. System.out.println("After changing name of t1:"+t1.getName());
16. }
17. }
Test it Now
Output:Name of t1:Thread-0
Name of t2:Thread-1
id of t1:8
running...
After changeling name of t1:Sonoo Jaiswal
running...
Current Thread
The currentThread() method returns a reference of currently executing thread.
1. public static Thread currentThread()
Example of currentThread() method
1. class TestMultiNaming2 extends Thread{
4. }
8.
9. t1.start();
10. t2.start();
11. }
12. }
Test it Now
Output:Thread-0
Thread-1
Priority of a Thread (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 defined 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:
1. class TestMultiPriority1 extends Thread{
3. System.out.println("running thread name is:"+Thread.currentThread().getName());
4. System.out.println("running thread priority is:"+Thread.currentThread().getPriority());
5.
6. }
8. TestMultiPriority1 m1=new TestMultiPriority1();
9. TestMultiPriority1 m2=new TestMultiPriority1();
10. m1.setPriority(Thread.MIN_PRIORITY);
11. m2.setPriority(Thread.MAX_PRIORITY);
12. m1.start();
13. m2.start();
14.
15. }
16. }
Test it Now
Output:running thread name is:Thread-0
running thread priority is:10
running thread name is:Thread-1
running thread priority is:1
Q) Synchronization in Java 7 marks

Answer ) Program must
Synchronization in Java is the capability to control the access of multiple threads to any shared resource.
Java Synchronization is better option where we want to allow only one thread to access the shared resource.
Why use Synchronization?
The synchronization is mainly used to
1. To prevent thread interference.
2. To prevent consistency problem.
Types of Synchronization
There are two types of synchronization
1. Process Synchronization
2. Thread Synchronization
Here, we will discuss only thread synchronization.
Thread Synchronization
There are two types of thread synchronization mutual exclusive and inter-thread communication.
1. Mutual Exclusive
1. Synchronized method.
2. Synchronized block.
3. Static synchronization.
2. Cooperation (Inter-thread communication in java)
Mutual Exclusive
Mutual Exclusive helps keep threads from interfering with one another while sharing data. It can be achieved by using
the following three ways:
1. By Using Synchronized Method
2. By Using Synchronized Block
3. By Using Static Synchronization
Concept of Lock in Java
Synchronization is built around an internal entity known as the lock or monitor. Every object has a lock associated with
it. By convention, a thread that needs consistent access to an object's fields has to acquire the object's lock before
accessing them, and then release the lock when it's done with them.
From Java 5 the package java.util.concurrent.locks contains several lock implementations.
Understanding the problem without Synchronization
In this example, there is no synchronization, so output is inconsistent. Let's see the example:
TestSynchronization1.java
1. class Table{
2. void printTable(int n){//method not synchronized
3. for(int i=1;i<=5;i++){
4. System.out.println(n*i);
5. try{
8. }
9.
10. }
11. }
12.
13. class MyThread1 extends Thread{
14. Table t;
15. MyThread1(Table t){
16. this.t=t;
17. }
19. t.printTable(5);
20. }
21.
22. }
24. Table t;
26. this.t=t;
27. }
30. }
31. }
32.
33. class TestSynchronization1{
35. Table obj = new Table();//only one object
36. MyThread1 t1=new MyThread1(obj);
38. t1.start();
39. t2.start();
40. }
41. }
Output:
5
100
10
200
15
300
20
400
25
500
Java Synchronized Method

If you declare any method as synchronized, it is known as 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.
TestSynchronization2.java
1. //example of java synchronized method
2. class Table{
3. synchronized void printTable(int n){//synchronized method
4. for(int i=1;i<=5;i++){
5. System.out.println(n*i);
6. try{
9. }
10.
11. }
12. }
13.
15. Table t;
17. this.t=t;
18. }
21. }
22.
23. }
25. Table t;
27. this.t=t;
28. }
31. }
32. }
33.
34. public class TestSynchronization2{
36. Table obj = new Table();//only one object
39. t1.start();
40. t2.start();
41. }
42. }
Output:
5
10
15
20
25
100
200
300
400
500
Daemon Thread in Java

Daemon thread in Java is a service provider thread that provides services to the user thread. Its
life depend on the mercy of user threads i.e. when all the user threads dies, JVM terminates this
thread automatically.
There are many java daemon threads running automatically e.g. gc, finalizer etc.
You can see all the detail by typing the jconsole in the command prompt. The jconsole tool
provides information about the loaded classes, memory usage, running threads etc.
Points to remember for Daemon Thread in Java
o It provides services to user threads for background supporting tasks. It has no role in life
than to serve user threads.
o Its life depends on user threads.
o It is a low priority thread.
Why JVM terminates the daemon thread if there is no user
thread?
The sole purpose of the daemon thread is that it provides services to user thread for
background supporting task. If there is no user thread, why should JVM keep running this
thread. That is why JVM terminates the daemon thread if there is no user thread. K In Java,
there are two types of threads:
1. Daemon Thread
2. User Thread
Daemon threads are low priority threads which always run in background and user
threads are high priority threads which always run in foreground. User Thread or Non-
Daemon are designed to do specific or complex task where as daemon threads are
used to perform supporting tasks.
Difference Between Daemon Threads And User Threads In Java
1. JVM doesn’t wait for daemon thread to finish but it waits for User Thread
: First and foremost difference between daemon and user threads is that JVM will
not wait for daemon thread to finish its task but it will wait for any active user
thread.
For example, one might have noticed this behavior while running Java program in
NetBeans that even if the main thread has finished, the top left down button is still
red, showing that Java program is still running. This is due to any user thread
spawned from the main thread, but with main thread one don’t see that red dot in
NetBeans.
2. Thread Priority : The User threads are high priority as compare to daemon
thread means they won’t get CPU as easily as a user thread can get.
3. Creation of Thread : User thread is usually created by the application for
executing some task concurrently. On the other hand, daemon thread is mostly
created by JVM like for some garbage collection job.
4. Termination of Thread : JVM will force daemon thread to terminate if all user
threads have finished their execution but The user thread is closed by application
or by itself. A user thread can keep running by the JVM running but a daemon
thread cannot keep running by the JVM. This is the most critical
difference between user thread and daemon thread.
5. Usage : The daemons threads are not used for any critical task. Any important
task is done by user thread. A daemon thread is generally used for some
background tasks which are not critical task.
The Major Difference between User and Daemon Threads:
User Thread Daemon Thread
JVM wait until user threads to finish their The JVM will’t wait for daemon threads to finish
work. It never exit until all user threads finish their work. The JVM will exit as soon as all user
their work. threads finish their work.
JVM will not force to user threads for

terminating, so JVM will wait for user threads If all user threads have finished their work JVM
to terminate themselves. will force the daemon threads to terminate
User threads are created by the application. Mostly Daemon threads created by the JVM.
Mainly user threads are designed to do some Daemon threads are design as to support the
specific task. user threads.
User threads are foreground threads. Daemon threads are background threads.
User threads are high priority threads. Daemon threads are low priority threads.
Its life independent. Its life depends on user threads.
fference between JDK, JRE, and JVM

Methods for Java Daemon thread by Thread class
The java.lang.Thread class provides two methods for java daemon thread.
No. Method Description
1) public void setDaemon(boolean is used to mark the current thread as daemon thread or user
status) thread.
2) public boolean isDaemon() is used to check that current is daemon.
Simple example of Daemon thread in java

File: MyThread.java
public class TestDaemonThread1 extends Thread{

2. if(Thread.currentThread().isDaemon()){//checking for daemon thread
3. System.out.println("daemon thread work");
4. }
5. else{
6. System.out.println("user thread work");
7. }
8. }
9. public static void main(String[] args){
10. TestDaemonThread1 t1=new TestDaemonThread1();//creating thread
11. TestDaemonThread1 t2=new TestDaemonThread1();
12. TestDaemonThread1 t3=new TestDaemonThread1();
13.
14. t1.setDaemon(true);//now t1 is daemon thread
15.
16. t1.start();//starting threads
17. t2.start();
18. t3.start();
19. }
20. }
Test it Now
Output:
daemon thread work
user thread work
user thread work
ThreadGroup in Java
Java provides a convenient way to group multiple threads in a single object. In such a way,
we can suspend, resume or interrupt a group of threads by a single method call.
Note: Now suspend(), resume() and stop() methods are deprecated.
Java thread group is implemented by java.lang.ThreadGroup class.
A ThreadGroup represents a set of threads. A thread group can also include the other
thread group. The thread group creates a tree in which every thread group except the
initial thread group has a parent.
A thread is allowed to access information about its own thread group, but it cannot access
the information about its thread group's parent thread group or any other thread groups.
Constructors of ThreadGroup class

There are only two constructors of ThreadGroup class.
No. Constructor Description
1) ThreadGroup(String name) creates a thread group with given name.
2) ThreadGroup(ThreadGroup parent, String name) creates a thread group with a given parent group and name.
Methods of ThreadGroup class

There are many methods in ThreadGroup class. A list of ThreadGroup methods is given below.
S.N. Modifier and Method Description

Type
1) void checkAccess() This method determines if the currently running thread has
permission to modify the thread group.
2) int activeCount() This method returns an estimate of the number of active threads in
the thread group and its subgroups.
3) int activeGroupCount() This method returns an estimate of the number of active groups in
the thread group and its subgroups.
4) void destroy() This method destroys the thread group and all of its subgroups.
5) int enumerate(Thread[] list) This method copies into the specified array every active thread in the
thread group and its subgroups.
6) int getMaxPriority() This method returns the maximum priority of the thread group.
7) String getName() This method returns the name of the thread group.
8) ThreadGroup getParent() This method returns the parent of the thread group.
9) void interrupt() This method interrupts all threads in the thread group.
10) boolean isDaemon() This method tests if the thread group is a daemon thread group.
11) void setDaemon(boolean This method changes the daemon status of the thread group.
daemon)
12) boolean isDestroyed() This method tests if this thread group has been destroyed.
13) void list() This method prints information about the thread group to the
standard output.
14) boolean parentOf(ThreadGroup g This method tests if the thread group is either the thread group
argument or one of its ancestor thread groups.
15) void suspend() This method is used to suspend all threads in the thread group.
16) void resume() This method is used to resume all threads in the thread group which
was suspended using suspend() method.
17) void setMaxPriority(int pri) This method sets the maximum priority of the group.
18) void stop() This method is used to stop all threads in the thread group.
19) String toString() This method returns a string representation of the Thread group.
Let's see a code to group multiple threads.
1. ThreadGroup tg1 = new ThreadGroup("Group A");

2. Thread t1 = new Thread(tg1,new MyRunnable(),"one");
3. Thread t2 = new Thread(tg1,new MyRunnable(),"two");
4. Thread t3 = new Thread(tg1,new MyRunnable(),"three");
Now all 3 threads belong to one group. Here, tg1 is the thread
group name, MyRunnable is the class that implements Runnable
interface and "one", "two" and "three" are the thread names.
Now we can interrupt all threads by a single line of code only.
1. Thread.currentThread().getThreadGroup().interrupt();
ThreadGroup Example
File: ThreadGroupDemo.java
public class ThreadGroupDemo implements Runnable{
1. public void run() {
3. }
4. public static void main(String[] args) {
5. ThreadGroupDemo runnable = new ThreadGroupDemo();
6. ThreadGroup tg1 = new ThreadGroup("Parent ThreadGroup");
7.
8. Thread t1 = new Thread(tg1, runnable,"one");
9. t1.start();
10. Thread t2 = new Thread(tg1, runnable,"two");
11. t2.start();
12. Thread t3 = new Thread(tg1, runnable,"three");
13. t3.start();
14.
15. System.out.println("Thread Group Name: "+tg1.getName());
16. tg1.list();
17.
18. }
19. }
Output:
one
two
three
Thread Group Name: Parent ThreadGroup
java.lang.ThreadGroup[name=Parent ThreadGroup,maxpri=10]

Iot Oops Chap 3

Uploaded by

Document Informationclick to expand document information

Copyright:

Available Formats

Iot Oops Chap 3

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Iot Oops Chap 3

Uploaded by

Copyright:

Available Formats

IOT OOPS USING JAVA CHAP 3

Q) Explain about Exception Handling in Java

What is exception handling

Difference between checked and

Common scenarios where exceptions may

2) Scenario where NullPointerException occurs

3) Scenario where NumberFormatException occurs

Java Exception Handling Keywords

Java try block

Problem without exception handling

Solution by exception handling

Java finally block is a block that is used to execute important

Why use java finally

Usage of Java finally

public static void main(String[] args) {

java throw keyword example

Example for Built-in methods

Example for Nested try

public static void main(String[] args) {

int a[]=new int[5];

System.out.println("rest of the code");

Example for throws

public class ThrowsExample {

int num1, num2, result;

void division() throws ArithmeticException {

class NotEligibleException extends Exception{

Q)What is multithreading? Explain with examples.

Advantages of Java Multithreading

Note: At least one process is required for each thread.

What is Thread in java

Note: At a time one thread is executed only.

Java Thread class

Java Thread Methods

1) void start() It is used to start the execution of the

2) void run() It is used to do an action for a thread.

3) static void sleep() It sleeps a thread for the specified

4) static Thread currentThread() It returns a reference to the currently

5) void join() It waits for a thread to die.

7) void setPriority() It changes the priority of the thread.

8) String getName() It returns the name of the thread.

9) void setName() It changes the name of the thread.

10) long getId() It returns the id of the thread.

Life cycle of a Thread (Thread States)

How to create thread

1. public void run(): is used to perform action for a thread.

1) Java Thread Example by extending Thread class

2) Java Thread Example by implementing Runnable interface

Sleep method in java

Example of sleep method in java

Can we start a thread twice

What if we call run() method directly instead

The join() method

public void join(long milliseconds)throws InterruptedException

public void setName(String name)

public long getId()

The currentThread() method:

Naming Thread and Current Thread

Priority of a Thread (Thread Priority):