UNIT-02 JAVA

✅ Q1. What is an Exception in Java? What is the fundamental idea behind exception
handling in Java?
Answer:
An exception in Java is an unexpected problem or abnormal event that arises during the
execution of a program and disrupts its normal flow. These are typically caused by situations
like dividing a number by zero, accessing an invalid index in an array, trying to open a non-
existing file, or receiving invalid user input. Exceptions are objects in Java that describe the
error condition and are instances of the class Throwable or its subclasses.
Java provides a robust exception handling mechanism that allows the program to detect
such problems and respond in a proper and controlled way, instead of crashing suddenly.
The main purpose of exception handling is to ensure the normal execution of the program
continues, even when something goes wrong.
The fundamental idea behind exception handling is to separate error-handling code from
regular code, making the program cleaner, more readable, and fault-tolerant. Java provides
built-in support for this using five key keywords:
 try: block that contains risky code
 catch: block that handles exceptions
 finally: block that always executes (cleanup)
 throw: used to explicitly throw an exception
 throws: used to declare an exception in method signature
By using these constructs, Java allows programs to detect and recover from problems,
provide user-friendly messages, and maintain program stability.

✅ Q2. What do we mean by Errors in Java?

Answer:
Errors in Java represent serious issues that are usually not recoverable by the application.
They occur due to conditions that are beyond the control of the programmer, such as
hardware failure, system crash, or memory exhaustion. Errors are part of the Java
exception hierarchy but are not considered the same as exceptions.
Errors are subclasses of the java.lang.Error class and are also derived from the Throwable
superclass like exceptions. However, they are fundamentally different because they signal
critical problems that a well-written application should not try to catch.
Some common types of errors include:
 OutOfMemoryError: occurs when the JVM runs out of memory.
 StackOverflowError: occurs when the call stack exceeds its limit, often due to infinite
recursion.
 VirtualMachineError: indicates a failure in the JVM itself.
Unlike exceptions, errors are not handled using try-catch blocks because they indicate
problems that require system-level fixes, not program-level corrections.

✅ Q3. Differentiate between Exceptions and Errors in Java.

Answer:
Both exceptions and errors are subclasses of the Throwable class in Java, but they differ in
purpose, cause, and handling approach. The table below shows the detailed difference:

Aspect Exception Error

Issues that occur during program Serious problems at system level

Definition
execution (logical mistakes). (hardware/JVM issues).

Mostly recoverable through Usually not recoverable by

Recoverability
programming logic. application.

Can be handled using try-catch Should not be handled using try-

Handling
blocks. catch.

Subclass of java.lang.Exception java.lang.Error

Checked by
Checked and unchecked both exist. Not checked by compiler.
compiler

OutOfMemoryError,
NullPointerException, IOException,
Examples StackOverflowError,
ArithmeticException
VirtualMachineError

✅ Q4. What are the different types of exceptions in Java? Provide examples for each type.
Answer:
In Java, exceptions are categorized into two major types:
1. Checked Exceptions
2. Unchecked Exceptions
1. Checked Exceptions:
 These are exceptions that are checked at compile time.
 The programmer is required to handle them using try-catch or declare them using
throws keyword.
 If not handled, the program will not compile.
 These usually occur due to external factors (like file handling, database access).
Examples:
 IOException: when a file cannot be read or opened.
 SQLException: when a database operation fails.
 ClassNotFoundException: when a class is not found during runtime.

2. Unchecked Exceptions:
 These are exceptions that occur at runtime.
 The compiler does not check them.
 Usually occur due to logic errors or programming mistakes.
Examples:
 NullPointerException: accessing a method on a null object.
 ArithmeticException: dividing a number by zero.
 ArrayIndexOutOfBoundsException: invalid index access in arrays.

This classification helps developers know which exceptions must be handled explicitly and
which may be left unhandled (but should still be managed properly for clean and user-
friendly applications).

✅ Q5. What do we mean by exceptions and unexceptions?

Answer:
The term “unexceptions” is not a formal Java term, but it seems to be referring to errors or
unhandled exceptions.
  Exceptions refer to abnormal but manageable conditions that occur during program
execution. These can be either checked or unchecked and are intended to be
handled in the program using proper exception handling techniques.
 Unexceptions, in context, could mean:
o Unrecoverable conditions like Errors (OutOfMemoryError,
StackOverflowError)
o Or exceptions that are not caught and lead to program termination.
So, we can understand:
 Exceptions = Abnormal, recoverable, manageable situations.
 Unexceptions = Critical or unmanaged situations that the program cannot recover
from.
To handle such cases, Java provides a hierarchy of throwable types and tools (try-catch,
throw, finally) to ensure the program can manage exceptions wherever possible, and inform
the user properly if something goes wrong.

✅ Q6. Describe the context behind exception handling when an exception occurs.
Answer:
When an exception occurs in Java, it means that something has gone wrong during the
runtime of a program. This could be a small issue (like an incorrect input from the user) or a
serious one (like a missing file). In the normal flow of execution, if no exception occurs, the
program runs sequentially. But when an exception arises, the normal flow breaks, and Java
immediately begins to search for a handler to manage the exception.
Java uses a structured model of exception handling. The context behind this mechanism is
to make the program more reliable and less prone to sudden termination. Instead of
crashing the program, Java lets us define how to respond when an error occurs. This
response is written in a special block called the catch block, which is used alongside a try
block.
When Java detects an exception:
 It jumps out of the normal execution.
 It checks if a proper catch block exists to handle that specific type of exception.
 If the exception is caught, the handler executes the corrective code.
 If it’s not caught, the program terminates abnormally, and the JVM prints a stack
trace showing where the error occurred.
This context of handling exceptions allows developers to:
  Avoid program crashes.
 Log or inform users about the issue.
 Perform recovery actions (like retrying, defaulting, or exiting gracefully).
 Improve program reliability and maintainability.
Thus, Java’s exception handling mechanism allows programs to anticipate and manage
errors, making them more secure and robust.

✅ Q7. How does Java manage the code flow when an exception occurs?
Answer:
When an exception occurs in Java, the normal sequence of code execution is interrupted.
Java then diverts the control flow to the nearest catch block that is capable of handling the
exception. This flow of control is essential for managing abnormal conditions in a predictable
manner.
Here is how Java handles code flow:
1. Normal Flow Before Exception:
o Code executes line by line in sequence.
o If no error occurs, try-catch blocks are ignored or completed normally.
2. When Exception Occurs:
o The program jumps out of the try block as soon as the error is detected.
o Java then starts searching for a matching catch block.
o The catch block must match the type of exception that was thrown.
3. After Catching:
o Once the matching catch block is found, the corresponding code is executed.
o After handling the exception, Java may execute a finally block if present.
4. If No Catch Block Found:
o If the exception is not handled, Java passes it up the method call stack.
o If no method in the call stack handles it, the JVM handles it, and the program
terminates abnormally.
In summary, Java’s exception mechanism ensures that the program doesn’t continue
executing invalid or dangerous code after an error has occurred, and gives developers a
chance to take appropriate action.
✅ Q8. How does Java react to exceptions when a program is performed?
Answer:
When a Java program is executed and an exception occurs, Java’s runtime system
immediately reacts to handle the situation. It does so through a process called exception
handling, which aims to prevent the program from crashing and gives the programmer a
way to respond properly to the problem.
Here’s how Java reacts:
 As soon as an exception is thrown, the normal flow of the program stops at that
point.
 The JVM starts searching for a matching catch block in the current method.
 If a catch block is present and matches the exception type, control is passed to it,
and the exception is handled.
 If no catch block is present, the exception is passed to the calling method.
 This continues up the call stack until the exception is either caught or it reaches the
top (main method).
 If it reaches the top and still no handler is found, the JVM handles the exception,
prints the stack trace, and terminates the program.
Java also provides the option of using a finally block which is always executed, regardless of
whether the exception was handled or not. This is usually used for closing files, releasing
resources, or cleanup activities.
This approach allows Java to respond immediately and precisely to problems, helping in
writing clean and safe programs.

✅ Q9. Explain how the JVM reacts to an unhandled exception in a program.

Answer:
When the Java Virtual Machine (JVM) encounters an exception that is not handled by the
program, it takes the responsibility of handling it by default. This is known as default
exception handling, and it leads to the abnormal termination of the program.
Here’s how the JVM reacts step-by-step:
1. When the JVM detects an unhandled exception (i.e., no matching catch block), it
stops the current execution path.
2. It then generates an error message, which includes:
o The name of the exception class.
o A description/message of the exception.
 o The stack trace, which shows where the exception occurred in the code.

3. After printing this message, the JVM terminates the program immediately.

This default behavior is not user-friendly, which is why developers are encouraged to handle
exceptions using try-catch blocks, so that the program can inform the user more gracefully
and possibly recover or take alternative action.

✅ Q10. Explain the proper usage of try-catch-finally blocks in exception handling.

Answer:
Java provides three main blocks—try, catch, and finally—to implement proper exception
handling. Each block plays a specific role in detecting, managing, and cleaning up after an
exception has occurred.
1. try block
 The try block contains the code that might cause an exception.
 It’s mandatory to have at least one catch or finally block after it.
 If no exception occurs, the catch block is skipped.
2. catch block
 The catch block is used to handle exceptions that are thrown in the try block.
 It must specify the type of exception it can handle.
 Multiple catch blocks can be used to handle different exception types.
3. finally block
 This block contains code that is always executed, whether an exception occurs or
not.
 It is mainly used to release resources like closing files, releasing memory, or database
connections.
Example syntax:
try {
// risky code
} catch (ArithmeticException e) {
// handling code
} finally {
// cleanup code
}
Using try-catch-finally helps maintain program control, avoid crashes, and ensure that
essential cleanup operations are always performed.

✅ Q11. What is the role of the throw keyword in exception handling? Provide an example.
Answer:
The throw keyword in Java is used to manually throw an exception during the execution of a
program. While Java automatically throws exceptions when certain errors occur (like dividing
by zero), the throw keyword allows the programmer to explicitly trigger an exception,
usually in response to custom logic or input validation.
This is especially useful when a program wants to enforce a rule or business logic, and exit
the current method or execution path by throwing an exception. The throw keyword must
be followed by an instance of a class that inherits from Throwable (either a built-in exception
or a user-defined one).
For example, if a method should not accept a negative number as input, you can manually
throw an IllegalArgumentException.
✅ Short Example (as requested):
if (age < 0) {
throw new IllegalArgumentException("Age cannot be negative");
}
In the above code, if the condition is met, an exception is created and thrown. If not caught,
this will stop the program. If caught using try-catch, the program can continue in a controlled
way.
The throw keyword is essential when the programmer wants to generate exceptions on
purpose for safety, validation, or custom error handling.

✅ Q12. When does the throw keyword contribute to exception handling in Java?
Answer:
The throw keyword contributes to exception handling in Java when there is a need to raise
an exception intentionally in a specific situation. Unlike exceptions that arise automatically
during program execution (like division by zero), the throw keyword is used when the
programmer detects something wrong (like invalid input, illegal state, or unexpected data)
and wants to interrupt the normal program flow.
This is often done for:
 Custom validations (e.g., input must not be negative).
 Manually triggering built-in exceptions with custom messages.
 Throwing user-defined exceptions that represent business-specific problems.
When throw is used inside a method, the method must either handle the exception using
try-catch, or declare it using throws (if it's a checked exception). This gives more control to
the developer in managing the flow of the program during error conditions.
Thus, the throw keyword helps in customizing error reporting, improving code safety, and
making program behavior predictable and robust when unexpected conditions arise.

✅ Q13. What are inbuilt exceptions? Give an example.

Answer:
Inbuilt exceptions (also called built-in exceptions) in Java are predefined exception classes
provided by the Java standard library. They are part of the java.lang package and some other
utility packages. These exceptions cover commonly occurring runtime and compile-time
errors, such as invalid input, arithmetic problems, or file-related issues.
These exceptions are already defined and ready to use. Java automatically throws these
exceptions when the corresponding error condition is met. The benefit of using inbuilt
exceptions is that developers don't need to define them manually, and they provide clear,
meaningful messages that make debugging easier.
✅ Examples of inbuilt exceptions:
 ArithmeticException: when dividing a number by zero.
 NullPointerException: when trying to access a method or variable from a null object.
 ArrayIndexOutOfBoundsException: when trying to access an invalid index in an array.
 IOException: when an input/output operation fails (e.g., file not found).
These exceptions can be caught and handled using try-catch blocks to prevent abnormal
termination and provide user-friendly feedback.

✅ Q14. What are user-defined exceptions in Java?

Answer:
User-defined exceptions are custom exception classes that are created by the programmer
to handle specific application-level errors that are not already covered by Java’s built-in
exceptions. They are useful when a particular problem is unique to your application or
business logic and requires a more meaningful, custom exception message or type.
To create a user-defined exception:
 You create a class that extends the Exception class (for checked exceptions) or
RuntimeException (for unchecked).
 You can also add a custom constructor to pass error messages.
 These exceptions can then be thrown using the throw keyword and handled using
try-catch blocks.
✅ Example of a user-defined exception:
class AgeException extends Exception {
AgeException(String msg) {
super(msg);
}
}

This exception can be thrown in the program wherever necessary using:

if (age < 18) {
throw new AgeException("Age must be 18 or above");
}
User-defined exceptions improve code clarity, error tracing, and make programs easier to
maintain, especially in large or complex projects where built-in exceptions are not enough.

✅ Q15. Differentiate between inbuilt and user-defined exceptions with examples.

Aspect Inbuilt Exceptions User-Defined Exceptions

Definition Exceptions already provided by Java. Exceptions created by the programmer.

Handle common errors like Handle specific business or application

Purpose
arithmetic, null, IO issues. errors.

Defined in Java libraries (e.g., Custom class extending Exception or

Class Name
NullPointerException). RuntimeException.

Limited to predefined types and Fully customizable with meaningful

Customization
messages. names and messages.

Example ArithmeticException, IOException AgeException, InvalidAmountException

✅ Q16. Differentiate user-defined exceptions in Java.
Answer:
User-defined exceptions in Java are custom exceptions created by the programmer to
represent application-specific or business-specific errors. These exceptions are used when
the built-in exceptions do not accurately describe the error condition that has occurred.
User-defined exceptions are broadly classified into two types:

1. Checked User-Defined Exceptions

 These extend the Exception class.
 They are checked at compile time.
 The compiler forces the programmer to either handle them using try-catch or
declare them using throws.
 Useful when we want to force the calling method to deal with the exception.
✅ Example:
class InvalidAgeException extends Exception {
public InvalidAgeException(String msg) {
super(msg);
}
}

2. Unchecked User-Defined Exceptions

 These extend the RuntimeException class.
 These exceptions are not checked at compile time, so handling them is optional.
 Used when the exception is due to programming logic errors or improper inputs that
can be avoided.
✅ Example:
class NegativeNumberException extends RuntimeException {
public NegativeNumberException(String msg) {
super(msg);
}
}
✅ Comparison Table:

Aspect Checked User-Defined Exception Unchecked User-Defined Exception

Base class Exception RuntimeException

Checked by
Yes No
compiler

Handling Must be handled or declared with

Handling is optional
requirement throws

Represent critical and unavoidable Represent programmer logic issues or

Purpose
situations invalid input

InvalidAgeException, NegativeNumberException,
Examples
AccountBlockedException EmptyInputException

✅ Q17. What is a byte stream in Java? Give a detailed explanation of commonly used byte
stream classes.
Answer:
In Java, byte streams are used to handle input and output of raw binary data such as audio,
images, video, or other non-text files. Byte streams process data in the form of 8-bit bytes,
and do not perform any character encoding or decoding. These streams are useful when we
are working with files where the data is not meant to be human-readable.
All byte stream classes in Java are derived from two abstract classes:
 InputStream for reading data.
 OutputStream for writing data.
These abstract classes are part of the java.io package and provide a foundation for several
useful subtypes.

✅ Common Byte Stream Classes and Their Definitions:

1. FileInputStream
o This class is used to read raw byte data from a file.
o It is often used to read binary files such as images, PDF files, or executable
files.
o It opens the file in binary mode and reads byte by byte.
 2. FileOutputStream
o This class is used to write raw byte data to a file.
o It is used for writing binary data, and can also be used to write text (although
not recommended due to encoding issues).
o If the file does not exist, it creates one; if it exists, it can overwrite or append.
3. BufferedInputStream
o This is a wrapper around InputStream that adds buffering for fast and
efficient reading.
o Instead of reading a byte at a time, it reads a large block and stores it in
memory (buffer), reducing disk access.
4. BufferedOutputStream
o Similar to BufferedInputStream, this class adds buffering to output streams.
o It writes data to a memory buffer first, and then writes it to the file in bulk,
which improves performance.
5. DataInputStream
o This class allows an application to read Java primitive data types like int,
float, boolean, etc., from an underlying input stream in a machine-
independent way.
o It is useful when reading structured binary data that was written using
DataOutputStream.
6. DataOutputStream
o Works together with DataInputStream. It is used to write Java primitive data
types in a platform-independent format.
o Used in network programming or binary file handling where structured data is
stored or transmitted.

In conclusion, byte streams are used when raw binary data needs to be transferred, and
each of the classes above helps improve performance, efficiency, or functionality while
working with files or sockets.

✅ Q18. What do you mean by character stream in Java? Explain the commonly used
character stream classes.
Answer:
Character streams in Java are used to perform input and output operations on text data.
Unlike byte streams, which handle 8-bit data, character streams deal with 16-bit Unicode
characters, making them suitable for reading and writing text in any language.
Java automatically handles character encoding and decoding with character streams,
making them ideal for text files like .txt, .csv, .html, and XML files.
Character stream classes are based on two abstract classes:
 Reader (for reading characters)
 Writer (for writing characters)
These base classes are extended by many specific classes to support different functionalities.

✅ Common Character Stream Classes and Their Definitions:

1. FileReader
o This class is used to read character data from a file.
o It reads text files character by character.
o It handles character encoding properly, unlike FileInputStream.
2. FileWriter
o Used to write character data to a file.
o It is the preferred way to write text content to a file.
o Automatically converts characters to bytes using platform-specific encoding.
3. BufferedReader
o Wraps around Reader (usually FileReader) and improves reading
performance by buffering the input.
o Also provides useful methods like readLine() to read entire lines of text
efficiently.
4. BufferedWriter
o Similar to BufferedReader, it improves the performance of writing character
data.
o Writes characters to a buffer first and flushes the data to the file in chunks,
minimizing disk I/O operations.
5. PrintWriter
o A subclass of Writer used to write formatted text to an output stream or file.
o It offers convenient methods like print() and println() similar to System.out.
 o Can write directly to files, sockets, or other output destinations with
character support.
✅ Q20. Explain the process of reading and writing bytes using byte streams in Java.
Answer:
In Java, reading and writing binary data (like images, audio, and PDF files) is done using byte
streams. The process involves using InputStream for reading and OutputStream for writing.
These streams operate on raw 8-bit bytes and are used when we need to handle non-
textual data.

✅ Reading Bytes using Byte Streams:

To read bytes from a file:
1. Create an instance of FileInputStream.
2. Use read() method to read one byte at a time or into a byte array.
3. Loop through until the end of the file is reached.
4. Close the stream using close() to release resources.
Behind the scenes:
 Each call to read() returns an integer (0 to 255) or -1 if the end is reached.
 Reading into a byte array improves performance.

✅ Writing Bytes using Byte Streams:

To write bytes to a file:
1. Create an instance of FileOutputStream.
2. Use write() method to write a single byte or a byte array.
3. Close the stream to ensure the data is flushed and the file is saved correctly.
Behind the scenes:
 The file is created or overwritten by default.
 A constructor with append mode can be used to prevent overwriting
✅ Q21. Describe the steps involved in reading and writing characters using character
streams in Java.
Answer:
When working with text data, Java recommends using character streams, which handle 16-
bit Unicode characters. These streams make sure that characters are correctly interpreted,
especially when the file uses special or multilingual characters. Java provides Reader and
Writer abstract classes to support this.

✅ Steps for Reading Characters:

1. Create a FileReader object to read from a text file.
2. Use read() to read one character at a time or use BufferedReader to read line by line
using readLine().
3. Continue reading until the end of the file is reached (read() returns -1 or readLine()
returns null).
4. Always close the stream using close() to release resources.

✅ Steps for Writing Characters:

1. Create a FileWriter object to write to a text file.
2. Use write() to write characters or strings to the file.
3. Optionally, use BufferedWriter for efficient writing.
4. Always flush and close the writer to ensure data is saved
✅ Q22. What are the advantages of using character streams over byte streams for
input/output operations in Java?
Answer:
Character streams are designed specifically to handle textual data in Java. They work with
Unicode characters, which makes them more appropriate for internationalized applications.
While byte streams operate at a lower level (raw bytes), character streams offer high-level,
text-aware input/output operations, making them more convenient and safer for text
handling.

✅ Major Advantages:
1. Automatic Encoding/Decoding:
o Character streams automatically handle character encoding, ensuring that
characters are not misinterpreted during reading/writing. This is crucial when
working with non-English or special characters.
2. Works Directly with Strings and Characters:
 o You can read and write directly using characters or strings instead of dealing
with raw bytes, making the code easier to write and understand.
3. Avoids Data Corruption:
o Text data remains accurate, unlike byte streams, which can corrupt characters
if encoding is not handled manually.
4. Better for Internationalization:
o Supports Unicode, so it can handle multiple languages and character sets
without extra effort.
5. Provides Useful Methods:
o Character stream classes like BufferedReader offer methods like readLine(),
making it easier to process line-by-line input.
6. Cleaner and More Readable Code:
o Reading and writing with character streams is more intuitive for text files, and
reduces complexity compared to byte streams.

✅ Conclusion:
Character streams are specialized for text handling, offer automatic encoding support, and
provide more programmer-friendly methods. While byte streams are required for binary
data, character streams are always preferred for handling text files due to their safety and
simplicity.

✅ Q23. What is a thread in Java? Explain its significance in programming.

Answer:
In Java, a thread is a lightweight sub-process or a smallest unit of execution within a
program. Java allows multiple threads to run concurrently, which means different tasks can
be performed at the same time without waiting for one to finish.
Java provides multithreading as a core feature of the language, which is useful for improving
performance, responsiveness, and efficient resource utilization, especially in applications
that involve background processing, real-time tasks, or I/O operations.

✅ Significance of Threads in Java:

1. Improved Performance: Threads share the same memory space, which reduces
overhead and improves execution speed.
 2. Parallel Execution: Threads enable parallelism — allowing multiple operations to run
simultaneously.
3. Better UI Responsiveness: In GUI-based programs, threads prevent the user interface
from freezing by separating heavy tasks.
4. Real-Time Systems: Threads are essential in games, simulations, or multimedia apps
where multiple things happen simultaneously.
5. Efficient Use of CPU: Threads help in utilizing multi-core processors efficiently by
executing multiple threads on different cores.
Java provides the Thread class and Runnable interface for creating and managing threads,
making multithreading easy to implement.

✅ Q24. Describe the life cycle of a thread in Java.

Answer:
The life cycle of a thread in Java refers to the various states a thread goes through from its
creation to completion. Java defines a well-structured thread life cycle managed by the
Thread Scheduler, which controls the execution of threads.

✅ States in Thread Life Cycle:

1. New (Created):
o A thread is in this state when it is instantiated using the Thread class.
o It is not yet started.
2. Runnable:
o When start() is called, the thread moves to the runnable state.
o It is ready to run but waiting for CPU time.
3. Running:
o The thread is currently executing its task.
o Only one thread can be in the running state at a time per CPU core.
4. Blocked:
o A thread is temporarily inactive because it is waiting to acquire a lock or
resource used by another thread.
5. Waiting:
o A thread is waiting indefinitely until another thread notifies it.
 o This occurs using methods like wait() and notify().
6. Timed Waiting:
o A thread is waiting for a specified time using sleep(time) or join(time).
7. Terminated (Dead):
o A thread enters this state when its run() method finishes or if it is stopped
due to an error.
o It cannot be restarted.

This life cycle ensures controlled and predictable execution of multithreaded programs.

✅ Q25. Differentiate between extending the Thread class and implementing the Runnable
interface.

Aspect Extending Thread Class Implementing Runnable Interface

Implements Runnable and passed to a

Class used Inherits directly from Thread
Thread object

Inheritance Cannot extend any other

Can extend another class
Limitation class

Less flexible due to single

Flexibility More flexible, promotes loose coupling
inheritance

Better for code sharing and object-

Code Reusability Limited code sharing
oriented design

Slightly more complex but more

Syntax Simplicity Slightly easier to write
professional

Large, scalable, and multi-threaded

Recommended For Simple and small applications
applications

✅ Q26. What is thread priority and why is it important in a multithreaded environment?

Answer:
Thread priority in Java is a value assigned to a thread to help the thread scheduler decide
the order of execution when multiple threads are waiting to run. It is an integer value
between 1 and 10, where:
 MIN_PRIORITY = 1
  NORM_PRIORITY = 5 (default)
 MAX_PRIORITY = 10
In a multithreaded environment, priorities are hints to the scheduler about the importance
of threads. Higher priority threads are more likely to be selected for execution, but the
exact behavior depends on the JVM and OS implementation.

✅ Importance of Thread Priority:

1. Task Management: Ensures that critical tasks are prioritized over less important
ones.
2. Improved Control: Developers can guide the scheduler to prefer time-sensitive
threads.
3. Prevent Starvation: Low-priority threads can be avoided if not managed carefully.
4. Fair Scheduling: When used wisely, it can help balance system resources.
However, thread priority should not be the sole method of controlling thread behavior, as it
is not guaranteed and platform-dependent.

✅ Q27. Explain how thread priority is important in a multithreaded environment.

Answer:
Thread priority plays a guiding role in determining which thread gets access to CPU time
first when multiple threads are in the runnable state. In a multithreaded environment, the
JVM's thread scheduler uses priority levels to decide which thread to execute next.
Threads with higher priority are generally chosen over lower-priority threads. For instance,
in a game:
 UI rendering thread may be given high priority.
 Background music thread may have medium priority.
 Logging or reporting threads may have low priority.
But it is important to note that thread priority is not always respected, especially in systems
that use time-sharing. Therefore, correct program logic should not depend solely on
priorities.
In conclusion, thread priority can help manage task urgency, but should be combined with
proper synchronization and design for reliable outcomes.
✅ Q28. What is thread synchronization? Discuss concepts related to thread
synchronization.
Answer:
Thread synchronization in Java is a technique used to control the access of multiple threads
to shared resources such as variables, methods, or objects. When two or more threads try
to access and modify the same data simultaneously, it can lead to data inconsistency or
unexpected behavior — this is called a race condition.
To prevent such issues, Java provides synchronization mechanisms to allow only one thread
at a time to access the critical section (shared resource).

✅ Key Concepts of Thread Synchronization:

1. Critical Section:
o A block of code that accesses shared resources and must not be executed by
more than one thread at a time.
2. Lock or Monitor:
o Each object in Java has a built-in lock (or monitor).
o A thread must acquire the lock of an object before entering its synchronized
method/block.
3. Synchronized Methods:
o Declared using the synchronized keyword.
o Only one thread can execute a synchronized method of the same object at a
time.
4. Synchronized Blocks:
o Allows finer control by synchronizing only a part of a method.
o Syntax: synchronized(object) { // critical section }
5. Intrinsic Locks:
o Every object has an associated monitor lock.
o Used implicitly in synchronization to prevent concurrent access.

✅ Importance:
Synchronization is essential in multithreaded environments where threads share data, to
ensure data consistency, avoid race conditions, and maintain program correctness.

✅ Q29. Describe various mechanisms for synchronizing threads in Java.

Answer:
Java provides several mechanisms to handle synchronization and ensure safe
communication among threads. These tools help prevent race conditions and inconsistent
behavior when multiple threads access shared data.

✅ 1. Synchronized Methods:
 Declared using the synchronized keyword.
 Entire method is locked; only one thread can execute it at a time.
✅ 2. Synchronized Blocks:
 Allows synchronization of only specific part of a method.
 Useful when only a section of code needs to be protected.
✅ 3. Static Synchronization:
 Used to synchronize static methods.
 The lock is on the class object, not on the instance.
✅ 4. Locks (java.util.concurrent.locks.Lock):
 More flexible than synchronized blocks.
 Allows try-locking, timed locking, and explicit unlock.

✅ 5. Volatile Keyword:
 Ensures visibility of changes made by one thread to other threads.
 Used for variables to prevent caching of values per thread.

Each mechanism serves different needs, and choosing the right one depends on the
complexity, performance, and safety requirements of the application.

✅ Q30. Discuss the need for synchronizing threads in a multithreaded environment.

Answer:
In a multithreaded environment, multiple threads often share the same memory space or
resources. If threads try to access and modify these shared resources simultaneously, it can
result in serious problems like:
 Race conditions
  Data inconsistency
 Unexpected output
 System crashes
To avoid these problems, thread synchronization is essential. Synchronization ensures that
only one thread accesses the critical section at a time, keeping the data consistent and
reliable.

✅ Reasons for Synchronization:

1. Avoid Data Corruption:
o Prevents multiple threads from updating a shared variable at the same time.
2. Maintain Data Consistency:
o Ensures that values remain correct and predictable.
3. Prevent Race Conditions:
o Avoids situations where the result depends on thread scheduling.
4. Thread Safety:
o Synchronization ensures that operations like withdraw, deposit, or update
happen safely in applications like banking or inventory systems.

Without synchronization, threads can interfere with each other, causing errors that are hard
to detect and debug. Thus, synchronization is a critical concept in multithreading to ensure
correctness and stability.

✅ Q31. What is inter-thread communication? How is it achieved in Java?

Answer:
Inter-thread communication in Java refers to the coordination between multiple threads so
that they can work together efficiently, especially when they are sharing resources or
performing related tasks.
Instead of using busy-waiting or constantly checking conditions (which wastes CPU time),
Java provides a more efficient way using wait-notify mechanism.

✅ Why it is Needed:
Imagine a situation where one thread produces data and another thread consumes it. The
consumer should wait until the producer produces data. This coordination is possible using
inter-thread communication.

✅ Achieved Using:
Java provides the following methods from the Object class:
1. wait() – causes the current thread to wait until another thread calls notify() or
notifyAll() on the same object.
2. notify() – wakes up one waiting thread.
3. notifyAll() – wakes up all waiting threads on that object.
These methods can only be called from within synchronized context (block or method),
otherwise a runtime exception is thrown.

This mechanism allows threads to pause and resume execution in a coordinated way,
making multithreading more efficient and intelligent.

✅ Q32. What is a semaphore?

Answer:
A semaphore is a synchronization tool used to control access to a shared resource by
multiple threads in a concurrent system. It maintains a set of permits and allows threads to
acquire or release permits to proceed with execution.
Semaphores are part of java.util.concurrent package and are used to implement resource
limits, like only allowing 3 threads to access a database at once.

✅ Types of Semaphores:
1. Counting Semaphore:
o Can have any number of permits.
o Used to limit the number of threads accessing a resource.
2. Binary Semaphore (Mutex):
o Has only 1 permit (like a lock).
o Either the resource is available or not.
✅ Key Methods:
 acquire() – waits until a permit is available.
 release() – releases a permit, allowing another thread to proceed.

Semaphores are useful in implementing resource pools, connection limits, and managing
bounded resources in concurrent applications.

✅ Q33. Provide examples illustrating the use of wait, notify, and notifyAll
methods for inter-thread communication (very short code).

Answer:

Here is a very short example to demonstrate the use of wait(), notify(), and notifyAll():

class SharedResource {
synchronized void produce() throws InterruptedException {
System.out.println("Producing...");
wait(); // Waits for notification
System.out.println("Resumed after notification");
}

synchronized void consume() {

System.out.println("Consuming...");
notify(); // Notifies one waiting thread
}
}
✅ Explanation:
 The produce() method puts the thread into waiting state.
 The consume() method notifies the waiting thread to resume.
 Both methods are synchronized, which is mandatory when using wait() and notify().