Java.io.File Class in Java

Java’s File class represents the pathname of a file or directory. Since file systems vary across platforms, using a simple string is not enough to handle file or directory names. The File class provides various methods to work with pathnames, such as deleting or renaming files, creating new directories, listing directory contents, and checking file or directory properties.

Key Features of the File Class

The File class acts as an abstract representation of file and directory pathnames. The pathname can either be absolute or relative, and you can obtain the parent directory by calling the getParent() method. An instance of the File class is immutable; once created, the pathname it represents doesn’t change.

The file system can impose certain access restrictions like read, write, or execute permissions on files or directories, referred to as access permissions.

How to Create a File Object

A File object is created by passing a string representing a file or directory name. You can use either a string or another File object. For example:

File file = new File("/home/user/docs/myfile.txt");

This creates a File object representing the myfile.txt file in the /home/user/docs directory.

Fields in the File Class

Constructors of the File Class

Methods of the File Class

1. File(File parent, String child): Creates a File instance from a parent directory and a child pathname.
2. File(String pathname): Creates a File instance from a string pathname.
3. File(String parent, String child): Creates a File instance from a parent directory string and a child pathname.
4. File(URI uri): Creates a File instance from a URI object.

import java.util.*;
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Example 1: Check if a File or Directory Exists

This program takes a filename or directory name as input, then checks if the file or directory exists and displays its properties.

import java.io.File;

class FileProperties {
    public static void main(String[] args) {
        String filename = args[0];
        File file = new File(filename);

        System.out.println("File Name: " + file.getName());
        System.out.println("Path: " + file.getPath());
        System.out.println("Absolute Path: " + file.getAbsolutePath());
        System.out.println("Parent: " + file.getParent());
        System.out.println("Exists: " + file.exists());

        if (file.exists()) {
            System.out.println("Writable: " + file.canWrite());
            System.out.println("Readable: " + file.canRead());
            System.out.println("Is Directory: " + file.isDirectory());
            System.out.println("File Size (bytes): " + file.length());
        }
    }
}

Output:

File Name: file.txt
Path: file.txt
Absolute Path: /home/user/file.txt
Parent: null
Exists: true
Writable: true
Readable: true
Is Directory: false
File Size (bytes): 100

Example 2: Display Directory Contents

This program accepts a directory path from the user and lists its contents.

import java.io.File;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

class DirectoryContents {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.println("Enter directory path:");
        String dirPath = br.readLine();

        File dir = new File(dirPath);

        if (dir.exists() && dir.isDirectory()) {
            String[] contents = dir.list();
            System.out.println("Contents of " + dirPath + ":");

            for (String item : contents) {
                File f = new File(dirPath, item);
                if (f.isFile()) {
                    System.out.println(item + " (File)");
                } else if (f.isDirectory()) {
                    System.out.println(item + " (Directory)");
                }
            }
        } else {
            System.out.println("Directory not found.");
        }
    }
}

Output:

Enter directory path:
/home/user/docs
Contents of /home/user/docs:
file1.txt (File)
file2.txt (File)
subfolder (Directory)

Java Program to Create a New File

Steps to Create a New File in Java

1. First Step: To create a new file in Java, we need to handle any potential exceptions properly. This is important because the file operations may throw exceptions. We will be using Java’s try-catch block for this purpose, which is one of the standard ways to handle exceptions.

2. Second Step: Next, we will import the File class, which is required to work with files in Java.

Example to create a File object:

File fileObject = new File(directoryPath);

Methods to Create a New File in Java

There are two main ways to create a file in Java:

1. Using the File class.

2. Using the FileOutputStream class.

These classes provide a variety of methods for performing file operations such as creating files, checking if a file exists, and more.

Let’s now look at examples of both approaches.

Example 1: Creating a File Using the File Class

In this approach, we use the File class to create a new file. This class represents an abstract path and allows us to work with the file without requiring its physical existence until necessary.

Code Example:

// Import necessary libraries
import java.io.File;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class FileCreator {

    public static void main(String[] args) {
        // Creating a new file using a custom method
        FileCreator creator = new FileCreator();
        creator.createNewFile();
    }

    // Method to create a new file
    public void createNewFile() {
        String filePath = "", fileName = "";

        // Use try-catch block to handle exceptions
        try {
            // Using BufferedReader to take user input for file name and path
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("Please enter the file name:");

            // Reading the file name from user input
            fileName = reader.readLine();
            System.out.println("Please enter the directory path:");

            // Reading the file path from user input
            filePath = reader.readLine();

            // Creating a new File object with the provided file name and path
            File file = new File(filePath + "/" + fileName + ".txt");

            // Method to create a new blank file
            if (file.createNewFile()) {
                System.out.println("File created: " + file.getName());
            } else {
                System.out.println("File already exists.");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Output:

Please enter the file name:
newFile
Please enter the directory path:
/Users/username/Desktop/Folder
File created: newFile.txt

Explanation:

• The program prompts the user to enter a file name and directory path.
• It uses the createNewFile() method from the File class to create the file.
• If the file is successfully created, it outputs the file name and path.

public static void main(String[] args) {
    // program logic
}

Example 2: Creating a File Using the FileOutputStream Class

Another way to create a file in Java is by using the FileOutputStream class. This class is used to write data to a file, and it can also be used to create a new file if one doesn’t already exist.

Code Example:

// Import necessary libraries
import java.io.FileOutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class FileCreator {

    public static void main(String[] args) {
        // Creating a new file using a custom method
        FileCreator creator = new FileCreator();
        creator.createNewFileWithStream();
    }

    // Method to create a new file using FileOutputStream
    public void createNewFileWithStream() {
        String filePath = "", fileName = "";

        // Use try-catch block to handle exceptions
        try {
            // Using BufferedReader to take user input for file name and path
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("Please enter the file name:");

            // Reading the file name from user input
            fileName = reader.readLine();
            System.out.println("Please enter the directory path:");

            // Reading the file path from user input
            filePath = reader.readLine();

            // Creating a new FileOutputStream object with the provided file name and path
            FileOutputStream fos = new FileOutputStream(filePath + "/" + fileName + ".txt");
            System.out.println("File created using FileOutputStream.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Output:

Please enter the file name:
newFile
Please enter the directory path:
/Users/username/Desktop/Folder
File created using FileOutputStream.

Java Program to Write into a File

In Java, several classes and methods are available to write data into files. The FileWriter class is commonly used for writing character-oriented data into files, and it plays a crucial role in Java’s file handling system. This article will discuss multiple ways to write data into a file using Java.

Methods to Write into a File in Java:

1. Using writeString() Method
2. Using FileWriter Class
3. Using BufferedWriter Class
4. Using FileOutputStream Class

Method 1: Using writeString() Method

Introduced in Java 11, the writeString() method allows writing text into a file. It requires the file path and character sequence as mandatory parameters. This method is simple and useful when the file content is relatively small.

Example:

// Import required classes
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class FileWriteExample {

    public static void main(String[] args) {
        // Define content to be written
        String content = "Hello, Java File Handling\nLet's write to a file!";

        // Define the path of the file
        Path filePath = Path.of("output.txt");

        try {
            // Write content to the file
            Files.writeString(filePath, content);

            // Read and print the content from the file
            String fileContent = Files.readString(filePath);
            System.out.println(fileContent);

        } catch (IOException e) {
            System.err.println("Error occurred: " + e.getMessage());
        }
    }
}

Output:

Hello, Java File Handling
Let's write to a file!

Method 2: Using FileWriter Class

FileWriter writes a stream of characters into a file. It’s ideal for smaller content. The following example demonstrates how to use the FileWriter class to write data to a file.

Example:

// Import necessary classes
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterExample {

    public static void main(String[] args) {
        // Content to write into the file
        String content = "Learning Java File Handling.";

        try {
            // Create FileWriter object
            FileWriter writer = new FileWriter("example.txt");

            // Write content to the file
            writer.write(content);

            // Print content
            System.out.println("Content written: " + content);

            // Close the writer
            writer.close();

            System.out.println("File has been written successfully.");
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}

Output:

Content written: Learning Java File Handling.
File has been written successfully.

Method 3: Using BufferedWriter Class

The BufferedWriter class provides better performance when writing larger content because it uses a buffer to write text efficiently. It is recommended for writing large files.

Example:

// Import necessary classes
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterExample {

    public static void main(String[] args) {
        // Content to write
        String content = "Buffered Writer in Java\nOptimized for large content.";

        try {
            // Create BufferedWriter object
            BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("buffered_output.txt"));

            // Write content to file
            bufferedWriter.write(content);

            // Print the content
            System.out.println("Content written: " + content);

            // Close the writer
            bufferedWriter.close();

            System.out.println("File written successfully.");
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}

Output:

Content written: Buffered Writer in Java
Optimized for large content.
File written successfully.

Delete a File Using Java

In Java, files can be permanently deleted using various methods, and unlike traditional delete operations in operating systems, these files do not go to the recycle bin or trash. Below is the method available in Java for deleting files.

Using java.io.File.delete() Method

The delete() method of the File class can be used to delete files or directories. It returns true if the file or directory is successfully deleted, and false otherwise.

Syntax:

public boolean delete()

Returns:

• true if the file or directory is deleted successfully.
• false if the file or directory cannot be deleted.

Example:

import java.io.File;

public class DeleteFileExample {

    public static void main(String[] args) {
        // Creating a file object
        File file = new File("example.txt");

        // Deleting the file
        if (file.delete()) {
            System.out.println("File deleted successfully.");
        } else {
            System.out.println("Failed to delete the file.");
        }
    }
}

Output:

File deleted successfully.

File Permissions in Java

Java File Permission Management

Java offers several methods to check and modify file permissions, which can be useful when restricting or allowing certain file operations. For instance, a file that is read-only can be updated to allow write operations or vice versa.

Checking Current File Permissions

A file in Java can be in any of the following permission states, and these can be checked using specific methods from the File class.

Example:

This Java program demonstrates how to check a file’s current permissions (readable, writable, executable).

import java.io.File;

public class FilePermissionCheck {

    public static void main(String[] args) {
        // Create a file object
        File file = new File("sample.txt");

        // Check if the file exists
        if (file.exists()) {
            // Display current file permissions
            System.out.println("Executable: " + file.canExecute());
            System.out.println("Readable: " + file.canRead());
            System.out.println("Writable: " + file.canWrite());
        } else {
            System.out.println("File not found.");
        }
    }
}

Output:

Executable: false
Readable: true
Writable: true

Changing File Permissions

Java provides several methods to alter file permissions for readability, writability, and executability.

Note:

• The setReadable() and setWritable() methods may fail if the underlying file system does not support changing permissions or if the user lacks appropriate privileges.

Example:

This program shows how to change a file’s permissions using Java methods.

import java.io.File;

public class FilePermissionModify {

    public static void main(String[] args) {
        // Create a file object
        File file = new File("document.txt");

        // Check if the file exists
        if (file.exists()) {
            // Modify the file permissions
            file.setExecutable(true);
            file.setReadable(true);
            file.setWritable(false);
            System.out.println("File permissions changed.");

            // Display updated permissions
            System.out.println("Executable: " + file.canExecute());
            System.out.println("Readable: " + file.canRead());
            System.out.println("Writable: " + file.canWrite());
        } else {
            System.out.println("File not found.");
        }
    }
}

Output:

File permissions changed.
Executable: true
Readable: true
Writable: false

FileWriter Class in Java

Java FileWriter Class Overview

The Java FileWriter class, part of the java.io package, is used to write data in character format to files. It is designed for handling character-based input/output and extends the OutputStreamWriter class, which in turn inherits from the Writer class.

Hierarchy of Java FileWriter Class

• FileWriter extends the OutputStreamWriter and Writer classes.
• It implements the Closeable, Flushable, Appendable, and AutoCloseable interfaces.

The FileWriter class creates the output file if it doesn’t already exist. It is specifically meant for character-based writing. If you need to write raw bytes, the FileOutputStream class should be used instead.

Constructors of FileWriter Class

1. FileWriter(File file): Creates a FileWriter object using a File object.

FileWriter fw = new FileWriter(new File("myfile.txt"));

2. FileWriter(File file, boolean append): Allows appending to an existing file if append is true; otherwise, it overwrites the file.

FileWriter fw = new FileWriter(new File("myfile.txt"), true);

3. FileWriter(FileDescriptor fd): Constructs a FileWriter using a file descriptor.

FileWriter fw = new FileWriter(FileDescriptor.out);

4. FileWriter(File file, Charset charset): Creates a FileWriter using a specific file and character set.

FileWriter fw = new FileWriter(new File("myfile.txt"), Charset.forName("UTF-8"));

5. FileWriter(String fileName): Creates a FileWriter using a file name.

FileWriter fw = new FileWriter("myfile.txt");

6. FileWriter(String fileName, boolean append): Creates a FileWriter to append or overwrite based on the boolean value.

FileWriter fw = new FileWriter("myfile.txt", true); // append

Example 1: Writing Data to a File

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterExample {

    public static void main(String[] args) {
        String data = "Hello, World!";
        try {
            FileWriter fw = new FileWriter("example.txt");
            fw.write(data);
            System.out.println("Data written successfully.");
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:

Data written successfully.

The file example.txt will contain the text: Hello, World!.

Overwriting vs Appending to a File

• Overwrite: When a file is created using a constructor with only the file name, any existing data in the file will be replaced.

FileWriter fw = new FileWriter("output.txt"); // overwrites

• Append: To append data to an existing file, a second parameter true is passed.

FileWriter fw = new FileWriter("output.txt", true); // appends

Example : Appending Data to a File

import java.io.FileWriter;
import java.io.IOException;

public class AppendFileExample {

    public static void main(String[] args) {
        String newData = " Welcome back!";
        try {
            FileWriter fw = new FileWriter("example.txt", true); // appending
            fw.write(newData);
            System.out.println("Data appended successfully.");
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:

Data appended successfully.

Basic Methods of FileWriter Class

1. write(int a): Writes a single character.

fw.write(65); // writes 'A' (ASCII value)

2. write(char[] cbuf): Writes an array of characters.

char[] data = {'H', 'i'};
fw.write(data);

3. write(String str): Writes a string to the file.

fw.write("Hello");

Example 4: Getting Encoding

The getEncoding() method retrieves the character encoding used by the FileWriter.

import java.io.FileWriter;
import java.nio.charset.Charset;
import java.io.IOException;

public class EncodingExample {

    public static void main(String[] args) {
        try {
            FileWriter fw1 = new FileWriter("output1.txt");
            FileWriter fw2 = new FileWriter("output2.txt", Charset.forName("UTF-8"));

            System.out.println("Encoding of fw1: " + fw1.getEncoding());
            System.out.println("Encoding of fw2: " + fw2.getEncoding());

            fw1.close();
            fw2.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Output:

Encoding of fw1: Cp1252
Encoding of fw2: UTF-8

Java.io.FileDescriptor in Java

java.io.FileDescriptor

The java.io.FileDescriptor class represents an opaque handle to machine-specific structures such as open files, sockets, or other byte streams. Its main use is to be passed to a FileInputStream or FileOutputStream for reading or writing data. Instances of this class should not be created by applications directly, as Java handles the underlying system details.

The FileDescriptor class offers several useful methods and fields for interacting with files and streams, including handles to the standard input, output, and error streams.

Fields:

• err: Handle for the standard error stream.
• in: Handle for the standard input stream.
• out: Handle for the standard output stream.

Declaration:

public final class FileDescriptor
extends Object

Methods:

1. sync():

This method ensures that all the data in the file descriptor’s buffers is written to the actual device. It is especially useful for making sure that written data is saved immediately.

Syntax:

public void sync()

2. Return Type: void

Exception: SyncFailedException: Thrown if synchronization cannot be guaranteed.

Example for sync() method:

import java.io.*;

public class SyncExample {
    public static void main(String[] args) throws IOException {
        FileDescriptor fileDescriptor = null;
        FileOutputStream fileOut = null;

        byte[] data = {65, 66, 67, 68};  // ASCII for 'ABCD'

        try {
            fileOut = new FileOutputStream("output.txt");
            fileDescriptor = fileOut.getFD();

            fileOut.write(data);

            // Synchronize data with the underlying device
            fileDescriptor.sync();
            System.out.println("Data synced successfully.");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileOut != null) {
                fileOut.close();
            }
        }
    }
}

Output:

Data synced successfully.

After running the above code, the file output.txt will contain the text:

ABCD

3. valid(): The valid() method checks if a FileDescriptor is valid.

Syntax:

public boolean valid()

4. Return Type:

• true: If the file descriptor is valid.
• false: If it is invalid.

Example:

import java.io.*;

public class ValidExample {
    public static void main(String[] args) throws IOException {
        FileDescriptor fileDescriptor = null;
        FileInputStream fileIn = null;

        try {
            fileIn = new FileInputStream("output.txt");
            fileDescriptor = fileIn.getFD();

            // Check if the FileDescriptor is valid
            boolean isValid = fileDescriptor.valid();
            System.out.println("FileDescriptor valid: " + isValid);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileIn != null) {
                fileIn.close();
            }
        }
    }
}

Output:

FileDescriptor valid: true

Synchronization in Java

In multithreaded applications, there are instances where multiple threads attempt to access shared resources simultaneously, which can lead to inconsistencies and unexpected results.

Why Use Synchronization in Java?

Java provides synchronization to ensure that only one thread can access a shared resource at any given time, thus avoiding conflicts.

Java Synchronized Blocks

Java offers a way to synchronize the tasks performed by multiple threads through synchronized blocks. A synchronized block is synchronized on a specific object, which acts as a lock. Only one thread can execute the code within the synchronized block while holding the lock, and other threads must wait until the lock is released.

General Form of Synchronized Block:

synchronized(lock_object) {
   // Code that needs synchronized access
}

Example:

import java.util.*;
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Output:

Hello, World!

This mechanism is implemented using monitors or locks in Java. A thread must acquire a lock on the object before entering the synchronized block, and it releases the lock once the block is exited.

Types of Synchronization:

1. Process Synchronization: Coordinates the execution of multiple processes to ensure shared resources are managed safely.
2. Thread Synchronization: Manages thread execution in multithreaded programs, with two main approaches:

• Mutual Exclusion (Synchronized methods, synchronized blocks, static synchronization)
• Cooperation (Inter-thread communication)

Example:

// Java program demonstrating synchronization

class Task {
    public void performTask(String message) {
        System.out.println("Executing\t" + message);
        try {
            Thread.sleep(800);
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted.");
        }
        System.out.println("\n" + message + " Completed");
    }
}

class TaskRunner extends Thread {
    private String message;
    Task task;

    TaskRunner(String msg, Task taskInstance) {
        message = msg;
        task = taskInstance;
    }

    public void run() {
        synchronized (task) {
            task.performTask(message);
        }
    }
}

public class SyncExample {
    public static void main(String[] args) {
        Task task = new Task();
        TaskRunner runner1 = new TaskRunner("Task 1", task);
        TaskRunner runner2 = new TaskRunner("Task 2", task);

        runner1.start();
        runner2.start();

        try {
            runner1.join();
            runner2.join();
        } catch (Exception e) {
            System.out.println("Thread interrupted");
        }
    }
}

Output:

Executing     Task 1

Task 1 Completed
Executing     Task 2

Task 2 Completed

Alternative Implementation Using Synchronized Method

We can also define the entire method as synchronized to achieve the same behavior without explicitly synchronizing blocks inside the thread’s run() method:

class Task {
    public synchronized void performTask(String message) {
        System.out.println("Executing\t" + message);
        try {
            Thread.sleep(800);
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted.");
        }
        System.out.println("\n" + message + " Completed");
    }
}

In this case, we don’t need to add the synchronized block in the run() method since the performTask() method itself is synchronized.

Example with Partial Synchronization of a Method

Sometimes, we may want to synchronize only part of the method instead of the entire method. Here’s how it can be done:

class Task {
    public void performTask(String message) {
        synchronized (this) {
            System.out.println("Executing\t" + message);
            try {
                Thread.sleep(800);
            } catch (InterruptedException e) {
                System.out.println("Thread interrupted.");
            }
            System.out.println("\n" + message + " Completed");
        }
    }
}

This is useful when only certain parts of the method need exclusive access to shared resources, while other parts can run concurrently.

Example of Synchronized Method Using Anonymous Class

class NumberPrinter {
    synchronized void printNumbers(int base) {
        for (int i = 1; i <= 3; i++) {
            System.out.println(base + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class AnonymousSyncExample {
    public static void main(String[] args) {
        final NumberPrinter printer = new NumberPrinter();

        Thread thread1 = new Thread() {
            public void run() {
                printer.printNumbers(10);
            }
        };

        Thread thread2 = new Thread() {
            public void run() {
                printer.printNumbers(20);
            }
        };

        thread1.start();
        thread2.start();
    }
}

Output:

11
12
13
21
22
23

Importance of Thread Synchronization in Java

Introduction to Multithreading

Multithreading is a technique where multiple parts of a program run simultaneously, optimizing resource utilization. Threads, which are essentially lightweight processes, enable concurrent execution within a single process. For instance, imagine you are editing a document in MS Word while also playing music and browsing the internet. These activities are different processes happening at the same time. Within each application, like a music player, there are multiple threads that handle tasks like loading songs, managing the playlist, and adjusting volume. In this way, threads represent smaller tasks within a larger process, and multithreading allows these tasks to run concurrently.

Multithreading becomes particularly relevant when considering thread synchronization, which is crucial to avoid inconsistencies when multiple threads attempt to access shared resources simultaneously.

Thread Priorities

In Java, every thread has a priority that indicates how it should be treated compared to other threads. Threads with higher priorities may be given more CPU time or preempt threads with lower priorities. However, when two threads of the same priority compete for the same resource, managing their execution becomes more complex and can lead to errors.

Consider a scenario where multiple computers are connected to a single printer. If two computers attempt to print documents at the same time, the printer could mix the two print jobs, producing invalid output. Similarly, when multiple threads with the same priority try to access a shared resource in a program, the results can become inconsistent.

Java addresses this issue through thread synchronization.

Thread Synchronization

Thread synchronization ensures that only one thread can access a shared resource at a time, preventing interference between threads and avoiding data inconsistency. Synchronization in Java is implemented using locks or monitors. When a thread acquires a lock on a resource, no other thread can access it until the lock is released. This ensures safe and orderly execution of threads.

There are two main types of synchronization:

1. Mutual Exclusion : Mutual exclusion is a technique to prevent multiple threads from interfering with each other while sharing a resource. It can be implemented through:

• Synchronized Methods
• Synchronized Blocks
• Static Synchronization

• Synchronized Methods : Using the synchronized keyword, we can ensure that a method is executed by only one thread at a time, making it thread-safe. Example:

class Printer {
    public void printJob(int jobNumber) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Job " + jobNumber + " is printing...");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Job1 extends Thread {
    Printer printer;
    Job1(Printer p) { printer = p; }
    public void run() { printer.printJob(1); }
}

class Job2 extends Thread {
    Printer printer;
    Job2(Printer p) { printer = p; }
    public void run() { printer.printJob(2); }
}

public class Main {
    public static void main(String[] args) {
        Printer p = new Printer();
        Job1 job1 = new Job1(p);
        Job2 job2 = new Job2(p);
        job1.start();
        job2.start();
    }
}

Output:

Job 1 is printing...
Job 2 is printing...
Job 1 is printing...
Job 2 is printing...
...

In this output, the jobs are printing simultaneously, leading to mixed and overlapping output.

Example 2: With Synchronized Method

class Printer {
    synchronized public void printJob(int jobNumber) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Job " + jobNumber + " is printing...");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Job1 extends Thread {
    Printer printer;
    Job1(Printer p) { printer = p; }
    public void run() { printer.printJob(1); }
}

class Job2 extends Thread {
    Printer printer;
    Job2(Printer p) { printer = p; }
    public void run() { printer.printJob(2); }
}

public class Main {
    public static void main(String[] args) {
        Printer p = new Printer();
        Job1 job1 = new Job1(p);
        Job2 job2 = new Job2(p);
        job1.start();
        job2.start();
    }
}

Output:

Job 1 is printing...
Job 1 is printing...
Job 1 is printing...
...
--------------------------
Job 2 is printing...
Job 2 is printing...
...

With synchronization, one job completes before the other starts, ensuring consistent output.

•  Synchronized Block: A synchronized block allows you to synchronize only a portion of the code rather than the entire method. This can be useful for optimizing performance when only specific code needs to be synchronized. Example:

class Printer {
    public void printJob(int jobNumber) {
        synchronized(this) {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Job " + jobNumber + " is printing...");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("Job " + jobNumber + " completed.");
    }
}

class Job1 extends Thread {
    Printer printer;
    Job1(Printer p) { printer = p; }
    public void run() { printer.printJob(1); }
}

class Job2 extends Thread {
    Printer printer;
    Job2(Printer p) { printer = p; }
    public void run() { printer.printJob(2); }
}

public class Main {
    public static void main(String[] args) {
        Printer p = new Printer();
        Job1 job1 = new Job1(p);
        Job2 job2 = new Job2(p);
        job1.start();
        job2.start();
    }
}

Output:

Job 1 is printing...
Job 1 is printing...
...
Job 1 completed.
Job 2 is printing...
...

• Static Synchronization in Java : Static synchronization in Java is used to synchronize static methods. When a static method is synchronized, the class-level lock is obtained. This ensures that only one thread can access any of the static synchronized methods of a class at a time, even if multiple threads are accessing different objects of the class. Example:

class Table {
    // Synchronized static method
    synchronized static void printTable(int n) {
        for (int i = 1; i <= 5; i++) {
            System.out.println(n * i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

class MyThread1 extends Thread {
    public void run() {
        Table.printTable(5);
    }
}

class MyThread2 extends Thread {
    public void run() {
        Table.printTable(10);
    }
}

public class StaticSynchronizationExample {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

        t1.start();
        t2.start();
    }
}

Output:

5
10
15
20
25
50
100
150
200
250

2. Inter-Thread Communication in Java: Inter-thread communication in Java allows threads to communicate with each other using methods like wait(), notify(), and notifyAll(). These methods are part of the Object class and must be called within synchronized blocks or methods.

This mechanism is useful when one thread needs to wait for a specific condition to be fulfilled by another thread.

class SharedResource {
    private int data;
    private boolean isProduced = false;

    synchronized void produce(int value) {
        while (isProduced) {
            try {
                wait(); // Wait until data is consumed
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
        data = value;
        System.out.println("Produced: " + data);
        isProduced = true;
        notify(); // Notify the consumer
    }

    synchronized void consume() {
        while (!isProduced) {
            try {
                wait(); // Wait until data is produced
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
        System.out.println("Consumed: " + data);
        isProduced = false;
        notify(); // Notify the producer
    }
}

class Producer extends Thread {
    SharedResource resource;

    Producer(SharedResource resource) {
        this.resource = resource;
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            resource.produce(i);
        }
    }
}

class Consumer extends Thread {
    SharedResource resource;

    Consumer(SharedResource resource) {
        this.resource = resource;
    }

    public void run() {
        for (int i = 1; i <= 5; i++) {
            resource.consume();
        }
    }
}

public class InterThreadCommunicationExample {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        Producer producer = new Producer(resource);
        Consumer consumer = new Consumer(resource);

        producer.start();
        consumer.start();
    }
}

Output:

Produced: 1
Consumed: 1
Produced: 2
Consumed: 2
Produced: 3
Consumed: 3
Produced: 4
Consumed: 4
Produced: 5
Consumed: 5

Method and Block Synchronization

Need for Synchronization

In a multithreaded environment, multiple threads often share access to the same fields and objects. While this form of communication can be highly efficient, it introduces potential issues such as thread interference and memory consistency errors. Synchronization constructs are crucial to prevent these errors.

Example of Synchronization Need

Consider the following example:

// Java program demonstrating the need for synchronization
class Counter {
    private int count = 0;

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class Test {
    public static void main(String[] args) {
        Counter counter = new Counter();
        counter.increment();
        System.out.println(counter.getCount());
    }
}

Output:

1

In this example, three key operations occur:

1. Fetch the current value of count.
2. Increment the fetched value.
3. Store the new value back in the count variable.

If multiple threads access this shared object, here’s what could happen:

• Thread 1 fetches the value of count (initially 0), increments it to 1.
• Thread 2 fetches the value of count, which is still 0 (because Thread 1 hasn’t saved it yet) and also increments it.

After both threads complete, the value of count is incorrectly set to 1 instead of 2. This shows why synchronization is necessary.

Synchronization in Java

In Java, synchronization ensures that only one thread at a time can access a shared resource, preventing the corruption of the object’s state. If multiple threads are only reading shared resources without modification, synchronization is not necessary.

Java provides two primary forms of synchronization:

1. Method-level synchronization
2. Block-level synchronization

1. Method Synchronization

Synchronized methods offer a straightforward way to prevent thread interference and memory consistency errors. If multiple threads call a synchronized method on the same object, only one thread can execute it at any given time.

Here’s an example of unsynchronized access to a shared resource:

// Example: Multiple threads accessing the same object without synchronization
class Printer {
    public void printNumbers() {
        for (int i = 0; i < 3; i++) {
            System.out.println(i);
            try {
                Thread.sleep(500);  // Simulate time-consuming task
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

class Worker extends Thread {
    Printer printer;

    Worker(Printer printer) {
        this.printer = printer;
    }

    public void run() {
        printer.printNumbers();
    }
}

public class Main {
    public static void main(String[] args) {
        Printer printer = new Printer();
        Worker thread1 = new Worker(printer);
        Worker thread2 = new Worker(printer);

        thread1.start();
        thread2.start();
    }
}

Output:

0
0
1
1
2
2

Multiple threads are accessing the shared Printer object simultaneously, leading to interleaved output.

Now, let’s use synchronization:

// Example: Synchronized method ensuring only one thread can access the method at a time
class Printer {
    synchronized public void printNumbers() {
        for (int i = 0; i < 3; i++) {
            System.out.println(i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

class Worker extends Thread {
    Printer printer;

    Worker(Printer printer) {
        this.printer = printer;
    }

    public void run() {
        printer.printNumbers();
    }
}

public class Main {
    public static void main(String[] args) {
        Printer printer = new Printer();
        Worker thread1 = new Worker(printer);
        Worker thread2 = new Worker(printer);

        thread1.start();
        thread2.start();
    }
}

Output:

0
1
2
0
1
2

Now, both threads access the printNumbers method in a synchronized way, ensuring that only one thread at a time can run it.

2. Block Synchronization

Sometimes, we need to synchronize only a portion of the code within a method instead of the entire method. This is called block-level synchronization. For example, if a method has 100 lines of code, but only 10 lines modify a shared resource, it’s efficient to synchronize just those 10 lines.

Example:

// Block synchronization example
import java.util.List;
import java.util.ArrayList;

class Person {
    String name = "";
    public int changeCount = 0;

    public void updateName(String newName, List<String> nameList) {
        synchronized (this) {
            name = newName;
            changeCount++;  // Keep track of how many times name is updated
        }

        // The rest of the code does not need synchronization
        nameList.add(newName);
    }
}

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        List<String> nameList = new ArrayList<>();

        person.updateName("Alice", nameList);
        System.out.println(person.name);
    }
}

Output:

Alice

Lock framework vs Thread synchronization

Thread synchronization can also be achieved using the Lock framework, introduced in java.util.concurrent.locks package. The Lock framework provides more control over locks compared to synchronized blocks. While synchronized blocks lock the entire method or a block of code, the Lock framework allows more flexibility and advanced locking mechanisms.

This new framework was introduced to address the limitations of traditional synchronization, such as when you have multiple methods that require synchronization. With traditional synchronized blocks, only one thread can access one synchronized method at a time. This can lead to performance issues, especially when many methods require synchronization.

The Lock framework overcomes this limitation by allowing different locks to be assigned to different sets of methods, thus increasing concurrency and improving overall performance.

Example Usage:

Lock lock = new ReentrantLock();
lock.lock();

// Critical section
lock.unlock();

The lock() method acquires the lock, and unlock() releases it. It is essential to ensure that every call to lock() is followed by a corresponding call to unlock(). Forgetting to call unlock() will result in a deadlock.

Key Considerations:

• Acquiring a lock without releasing it will result in deadlock.
• The number of lock() calls should always match the number of unlock() calls.
• Unlocking without having first acquired the lock will throw an exception.

Example Scenario

In the following example, a shared resource class (Resource) contains two methods, each with its own lock. The DisplayTask and ReadTask classes represent two different jobs that will be executed by multiple threads. Using different locks for these two methods allows the tasks to be executed concurrently without interference.

import java.util.Date;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// Main class demonstrating the Lock framework
public class LockExample {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        Thread[] threads = new Thread[10];

        // Creating threads for DisplayTask
        for (int i = 0; i < 5; i++) {
            threads[i] = new Thread(new DisplayTask(resource), "Thread " + i);
        }

        // Creating threads for ReadTask
        for (int i = 5; i < 10; i++) {
            threads[i] = new Thread(new ReadTask(resource), "Thread " + i);
        }

        // Starting all threads
        for (int i = 0; i < 10; i++) {
            threads[i].start();
        }
    }
}

// Task for displaying a record
class DisplayTask implements Runnable {
    private SharedResource resource;

    DisplayTask(SharedResource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        System.out.println("Executing display task");
        resource.displayRecord();
    }
}

// Task for reading a record
class ReadTask implements Runnable {
    private SharedResource resource;

    ReadTask(SharedResource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        System.out.println("Executing read task");
        resource.readRecord();
    }
}

// Shared resource class with two methods having different locks
class SharedResource {
    private final Lock displayLock = new ReentrantLock();
    private final Lock readLock = new ReentrantLock();

    // Synchronized displayRecord method using displayLock
    public void displayRecord() {
        displayLock.lock();
        try {
            long duration = (long) (Math.random() * 10000);
            System.out.println(Thread.currentThread().getName() + ": Displaying record for " + (duration / 1000) + " seconds :: " + new Date());
            Thread.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + ": Display completed");
            displayLock.unlock();
        }
    }

    // Synchronized readRecord method using readLock
    public void readRecord() {
        readLock.lock();
        try {
            long duration = (long) (Math.random() * 10000);
            System.out.println(Thread.currentThread().getName() + ": Reading record for " + (duration / 1000) + " seconds :: " + new Date());
            Thread.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + ": Read completed");
            readLock.unlock();
        }
    }
}

Output:

Executing display task
Executing display task
Executing display task
Executing display task
Executing display task
Executing read task
Executing read task
Executing read task
Executing read task
Executing read task
Thread 0: Displaying record for 3 seconds :: Mon Oct 16 11:59:42 IST 2024
Thread 5: Reading record for 5 seconds :: Mon Oct 16 11:59:42 IST 2024
Thread 0: Display completed
Thread 1: Displaying record for 4 seconds :: Mon Oct 16 11:59:45 IST 2024
Thread 5: Read completed
Thread 6: Reading record for 5 seconds :: Mon Oct 16 11:59:47 IST 2024
Thread 1: Display completed

Differences Between Lock and Synchronized:

Deadlock in Java Multithreading

The synchronized keyword in Java is used to ensure that a class or method is thread-safe, meaning that only one thread at a time can hold the lock for the synchronized method or block. This forces other threads to wait until the lock is released. It becomes essential in multi-threaded environments where multiple threads are running concurrently. However, this can also introduce a problem known as deadlock.

What is Deadlock?

Deadlock occurs when two or more threads are blocked forever, each waiting on the other to release the lock. This happens when multiple synchronized blocks or methods are trying to acquire locks on each other’s objects, leading to an indefinite waiting state.

Example of Deadlock

In the following example, two threads attempt to call synchronized methods on two shared objects. This causes a deadlock because each thread holds a lock that the other needs in order to proceed.

class Utility {
    // Method to sleep the current thread for a specified time
    static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// Shared class used by both threads
class SharedResource {
    // Synchronized method that locks the current object and tries to call another method
    synchronized void method1(SharedResource resource) {
        System.out.println(Thread.currentThread().getName() + " enters method1 of " + this);
        Utility.sleep(1000);
        resource.method2();
        System.out.println(Thread.currentThread().getName() + " exits method1 of " + this);
    }

    synchronized void method2() {
        System.out.println(Thread.currentThread().getName() + " enters method2 of " + this);
        Utility.sleep(1000);
        System.out.println(Thread.currentThread().getName() + " exits method2 of " + this);
    }
}

// Thread1 tries to call method1 on shared resources
class ThreadOne extends Thread {
    private SharedResource resource1;
    private SharedResource resource2;

    public ThreadOne(SharedResource resource1, SharedResource resource2) {
        this.resource1 = resource1;
        this.resource2 = resource2;
    }

    @Override
    public void run() {
        resource1.method1(resource2);
    }
}

// Thread2 tries to call method1 on shared resources
class ThreadTwo extends Thread {
    private SharedResource resource1;
    private SharedResource resource2;

    public ThreadTwo(SharedResource resource1, SharedResource resource2) {
        this.resource1 = resource1;
        this.resource2 = resource2;
    }

    @Override
    public void run() {
        resource2.method1(resource1);
    }
}

public class DeadlockExample {
    public static void main(String[] args) {
        SharedResource resource1 = new SharedResource();
        SharedResource resource2 = new SharedResource();

        ThreadOne threadOne = new ThreadOne(resource1, resource2);
        threadOne.setName("Thread1");
        threadOne.start();

        ThreadTwo threadTwo = new ThreadTwo(resource1, resource2);
        threadTwo.setName("Thread2");
        threadTwo.start();

        Utility.sleep(2000);  // Allow threads to attempt execution
    }
}

Output:

Thread1 enters method1 of SharedResource@1540e19d
Thread2 enters method1 of SharedResource@677327b6

Explanation:

1. Thread1 acquires a lock on resource1 and enters the method1() method.
2. At the same time, Thread2 acquires a lock on resource2 and enters its method1() method.
3. Both threads try to acquire locks on the other’s resource (i.e., Thread1 tries to lock resource2, and Thread2 tries to lock resource1), causing a deadlock where both are stuck indefinitely waiting for the other to release the lock.

Detecting Deadlock

Deadlock detection can be done by collecting a thread dump of your program. On Windows, you can use the following command:

jcmd <PID> Thread.print

Where <PID> is the Process ID of your running program, which can be obtained using the jps command. The thread dump will reveal if a deadlock condition has occurred by indicating threads that are waiting for each other.

Avoiding Deadlock

While deadlock is difficult to eliminate entirely, you can reduce its likelihood by adopting the following practices:

1. Avoid Nested Locks: Deadlock often occurs when multiple locks are required. Try to avoid locking more than one resource at a time.
2. Avoid Unnecessary Locks: Only lock resources when absolutely necessary to minimize contention.
3. Use Thread Join with Timeout: Deadlocks can occur when threads wait indefinitely for each other. Using Thread.join() with a timeout ensures that threads won’t wait forever and can recover if necessary.

Reentrant Lock in Java

In Java, traditional thread synchronization is typically achieved through the use of the synchronized keyword. While this provides basic synchronization, it can be somewhat rigid. For instance, a thread can acquire a lock only once, and there’s no built-in mechanism to manage waiting threads. This can lead to situations where certain threads are starved of resources, potentially for long periods of time.

To offer more flexibility, Java provides ReentrantLocks, which are part of the java.util.concurrent.locks package. They allow more advanced control over thread synchronization, overcoming some of the limitations of the synchronized keyword.

What are Reentrant Locks?

The ReentrantLock class implements the Lock interface and provides synchronization capabilities for methods accessing shared resources. In code, you can wrap the critical section (the part of the code that manipulates shared resources) with lock() and unlock() calls. This ensures that only the thread holding the lock can access the shared resource, while others are blocked.

As the name suggests, ReentrantLock allows the same thread to acquire the lock multiple times. Each time a thread locks the resource, a “hold count” is incremented. This count is decremented each time the thread calls unlock(), and the resource is only truly unlocked when the count reaches zero.

A notable feature of ReentrantLock is its fairness parameter. When fairness is enabled (by passing true to the constructor), the lock is granted to the thread that has been waiting the longest, thereby preventing thread starvation.

Example Usage

public void someMethod() {
    reentrantLock.lock();
    try {
        // Perform operations on shared resource
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        reentrantLock.unlock();
    }
}

The unlock() call is placed inside the finally block to ensure that the lock is released even if an exception occurs during the execution of the try block.

Key Methods of ReentrantLock

• lock(): Acquires the lock and increments the hold count.
• unlock(): Decrements the hold count. When the count reaches zero, the lock is released.
• tryLock(): Attempts to acquire the lock without blocking. If the lock is available, the method returns true; otherwise, it returns false.
• tryLock(long timeout, TimeUnit unit): Waits for the specified time to acquire the lock before giving up.
• lockInterruptibly(): Acquires the lock unless the thread is interrupted.
• getHoldCount(): Returns the number of times the current thread has acquired the lock.
• isHeldByCurrentThread(): Checks if the lock is held by the current thread.
• isLocked(): Checks if the lock is held by any thread.
• hasQueuedThreads(): Checks if any threads are waiting to acquire the lock.
• newCondition(): Returns a Condition object for more complex thread interactions.

ReentrantLock Example

Below is an example that demonstrates how to use ReentrantLock in a multi-threaded scenario:

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

class Worker implements Runnable {
    private String taskName;
    private ReentrantLock lock;

    public Worker(ReentrantLock lock, String taskName) {
        this.lock = lock;
        this.taskName = taskName;
    }

    @Override
    public void run() {
        boolean taskCompleted = false;

        while (!taskCompleted) {
            if (lock.tryLock()) {
                try {
                    // Outer lock acquired
                    Date now = new Date();
                    SimpleDateFormat formatter = new SimpleDateFormat("HH:mm:ss");
                    System.out.println(taskName + " - Acquired outer lock at " + formatter.format(now));
                    Thread.sleep(1000);

                    // Inner lock
                    lock.lock();
                    try {
                        now = new Date();
                        System.out.println(taskName + " - Acquired inner lock at " + formatter.format(now));
                        System.out.println("Hold count: " + lock.getHoldCount());
                        Thread.sleep(1000);
                    } finally {
                        // Release inner lock
                        System.out.println(taskName + " - Releasing inner lock");
                        lock.unlock();
                    }
                    taskCompleted = true;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // Release outer lock
                    System.out.println(taskName + " - Releasing outer lock");
                    lock.unlock();
                }
            } else {
                System.out.println(taskName + " - Waiting for lock");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class ReentrantLockExample {
    private static final int THREAD_COUNT = 3;

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);

        executorService.execute(new Worker(lock, "Task1"));
        executorService.execute(new Worker(lock, "Task2"));
        executorService.execute(new Worker(lock, "Task3"));

        executorService.shutdown();
    }
}

Output:

Task1 - Acquired outer lock at 10:15:30
Task2 - Waiting for lock
Task3 - Waiting for lock
Task1 - Acquired inner lock at 10:15:31
Hold count: 2
Task1 - Releasing inner lock
Task1 - Releasing outer lock
Task2 - Acquired outer lock at 10:15:32
Task2 - Acquired inner lock at 10:15:33
Hold count: 2
Task2 - Releasing inner lock
Task2 - Releasing outer lock
Task3 - Acquired outer lock at 10:15:34
Task3 - Acquired inner lock at 10:15:35
Hold count: 2
Task3 - Releasing inner lock
Task3 - Releasing outer lock

Difference Between Lock and Monitor in Java Concurrency

Java Concurrency

Java concurrency involves handling multiple threads to maximize CPU usage by ensuring efficient processing of tasks and reducing idle CPU time. The need for synchronization in multithreading has given rise to constructs like locks (or mutex) and monitors, which help control access to shared resources. Originally, locks were used for thread synchronization, but later, monitors provided a more robust and error-free mechanism.

Before diving into the differences between locks and monitors, let’s first look at their individual characteristics.

Overview of Lock (Mutex)

Locks were originally used as part of thread management to control access to shared resources. Threads would check flags to determine whether a resource was available (unlocked) or in use (locked). Now, Java provides a more explicit way of using locks through the Lock interface in the concurrency API. This method gives developers better control over locking mechanisms than the traditional implicit locking provided by monitors.

Here is an example that demonstrates basic lock usage:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class SharedResource {
    private Lock lock = new ReentrantLock();

    public void performTask(String threadName) {
        lock.lock();  // Acquiring lock
        try {
            System.out.println(threadName + " has acquired the lock.");
            Thread.sleep(1000); // Simulating some work
            System.out.println(threadName + " is performing the task.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();  // Releasing lock
            System.out.println(threadName + " has released the lock.");
        }
    }
}

public class LockExample {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        Thread t1 = new Thread(() -> resource.performTask("Thread 1"));
        Thread t2 = new Thread(() -> resource.performTask("Thread 2"));

        t1.start();
        t2.start();
    }
}

Overview of Monitor

Monitors provide a more structured approach to synchronization in Java. They ensure that only one thread at a time can access a critical section of code. Monitors are implemented in Java through the synchronized keyword (applied to methods or code blocks), ensuring mutual exclusion between threads. Additionally, they allow threads to cooperate when working on shared tasks.

Let’s look at a simple example where two threads are synchronized to use a shared resource:

class SharedPrinter {

    // Synchronized method to ensure one thread at a time
    synchronized public void printMessage(String message) {
        for (char c : message.toCharArray()) {
            System.out.print(c);
            try {
                Thread.sleep(100);  // Simulate some delay
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println();
    }
}

class PrinterThread extends Thread {
    private SharedPrinter printer;
    private String message;

    public PrinterThread(SharedPrinter printer, String message) {
        this.printer = printer;
        this.message = message;
    }

    public void run() {
        printer.printMessage(message);
    }
}

public class MonitorExample {
    public static void main(String[] args) {
        SharedPrinter printer = new SharedPrinter();
        Thread t1 = new PrinterThread(printer, "Hello");
        Thread t2 = new PrinterThread(printer, " World!");

        t1.start();
        t2.start();
    }
}

Output:

HWeolrlod!

Key Differences Between Lock and Monitor in Java

Introduction

Multithreading is a key feature in Java that enables the concurrent execution of multiple parts of a program, maximizing CPU utilization. Each independent path of execution is called a thread, which is a lightweight process.

Java provides two primary ways to create threads:

1. By extending the Thread class
2. By implementing the Runnable interface

Creating a Thread by Extending the Thread Class

In this approach, you create a class that extends java.lang.Thread and override the run() method. The thread starts when you call start(), which internally invokes run() on a new thread.

Example

// Java code for thread creation by extending the Thread class
class ThreadDemo extends Thread {
    public void run() {
        try {
            // Displaying the ID of the thread that is running
            System.out.println("Thread " + Thread.currentThread().getId() + " is active");
        } catch (Exception e) {
            System.out.println("An exception occurred");
        }
    }
}

// Main Class
public class ThreadExample {
    public static void main(String[] args) {
        int numberOfThreads = 5;
        for (int i = 0; i < numberOfThreads; i++) {
            ThreadDemo threadInstance = new ThreadDemo();
            threadInstance.start();
        }
    }
}

Sample Output (varies by system):

Thread 11 is active
Thread 13 is active
Thread 12 is active
Thread 15 is active
Thread 14 is active

Creating a Thread by Implementing the Runnable Interface

In this approach, you implement the Runnable interface and define the thread task inside run(). Then you pass the Runnable object to a Thread and call start().

Example

// Java code for thread creation by implementing the Runnable interface
class ThreadRunnableDemo implements Runnable {
    public void run() {
        try {
            System.out.println("Thread " + Thread.currentThread().getId() + " is active");
        } catch (Exception e) {
            System.out.println("An exception occurred");
        }
    }
}

// Main Class
public class RunnableExample {
    public static void main(String[] args) {
        int numberOfThreads = 5;
        for (int i = 0; i < numberOfThreads; i++) {
            Thread threadInstance = new Thread(new ThreadRunnableDemo());
            threadInstance.start();
        }
    }
}

✅ Why Runnable is often preferred: your class can still extend another class (Java doesn’t allow multiple inheritance of classes).

Thread Life Cycle (Thread States)

A thread can exist in only one state at a time. The main states are:

1. New
2. Runnable
3. Blocked
4. Waiting
5. Timed Waiting
6. Terminated

State Explanations

• New: Thread object is created but start() hasn’t been called.
• Runnable: Thread is ready to run (it may actually be running or waiting for CPU).
• Blocked: Thread is waiting to acquire a monitor lock (e.g., trying to enter a synchronized block).
• Waiting: Thread waits indefinitely (e.g., join() or wait() without timeout).
• Timed Waiting: Thread waits for a fixed time (e.g., sleep(ms) or wait(timeout)).
• Terminated: Thread has finished execution.

Java Enum Constants for Thread States

Java provides these states via Thread.State:

• NEW
• RUNNABLE
• BLOCKED
• WAITING
• TIMED_WAITING
• TERMINATED

Example: Demonstrating Thread States

// Java program to demonstrate thread states
class MyThread implements Runnable {
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("State of thread1 after calling join() on thread2 - "
                + ThreadExample.thread1.getState());

        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadExample implements Runnable {
    public static Thread thread1;
    public static ThreadExample obj;

    public static void main(String[] args) {
        obj = new ThreadExample();
        thread1 = new Thread(obj);

        System.out.println("State of thread1 after creating it - " + thread1.getState());
        thread1.start();

        System.out.println("State of thread1 after calling .start() method - " + thread1.getState());
    }

    public void run() {
        MyThread task = new MyThread();
        Thread thread2 = new Thread(task);

        System.out.println("State of thread2 after creating it - " + thread2.getState());
        thread2.start();

        System.out.println("State of thread2 after calling .start() method - " + thread2.getState());

        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("State of thread2 after calling .sleep() method - " + thread2.getState());

        try {
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("State of thread2 after it has completed execution - " + thread2.getState());
    }
}

Java Thread Priority in Multithreading

Thread priority is an integer from 1 to 10:

• Thread.MIN_PRIORITY = 1
• Thread.NORM_PRIORITY = 5 (default)
• Thread.MAX_PRIORITY = 10

You can use:

• getPriority() to read priority
• setPriority(int) to change priority

Note: Priority influences scheduling, but the OS/JVM scheduler may still behave differently.

Example: Getting and Setting Priorities

class PriorityExample extends Thread {
    public void run() {
        System.out.println("Inside run method of thread: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        PriorityExample t1 = new PriorityExample();
        PriorityExample t2 = new PriorityExample();
        PriorityExample t3 = new PriorityExample();

        System.out.println("t1 priority: " + t1.getPriority());
        System.out.println("t2 priority: " + t2.getPriority());
        System.out.println("t3 priority: " + t3.getPriority());

        t1.setPriority(3);
        t2.setPriority(7);
        t3.setPriority(10);

        System.out.println("Updated t1 priority: " + t1.getPriority());
        System.out.println("Updated t2 priority: " + t2.getPriority());
        System.out.println("Updated t3 priority: " + t3.getPriority());
    }
}

Child Thread Inherits Parent Priority

class ChildThreadExample extends Thread {
    public void run() {
        System.out.println("Running thread: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread.currentThread().setPriority(6);
        System.out.println("Main thread priority: " + Thread.currentThread().getPriority());

        ChildThreadExample t1 = new ChildThreadExample();
        System.out.println("Child thread priority: " + t1.getPriority());
    }
}

Main Thread in Java

When the Java program starts, the first thread is the main thread.
It often:

1. creates child threads
2. finishes last (because it may coordinate shutdown)

Example: Controlling the Main Thread

public class MainThreadControl {
    public static void main(String[] args) {

        Thread mainThread = Thread.currentThread();

        System.out.println("Current thread: " + mainThread.getName());

        mainThread.setName("PrimaryThread");
        System.out.println("After name change: " + mainThread.getName());

        System.out.println("Main thread priority: " + mainThread.getPriority());

        mainThread.setPriority(Thread.MAX_PRIORITY);
        System.out.println("Main thread new priority: " + mainThread.getPriority());
    }
}

Deadlock Using Main Thread (Concept Example)

Calling join() on the current thread causes it to wait for itself → deadlock.

public class DeadlockExample {
    public static void main(String[] args) {
        try {
            System.out.println("Entering Deadlock");
            Thread.currentThread().join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Thread Naming in Java

1) Naming at Creation (Direct Method)

class CustomThread extends Thread {
    CustomThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(getName() + " is running...");
    }
}

public class ThreadNamingDemo {
    public static void main(String[] args) {
        CustomThread t1 = new CustomThread("Worker1");
        CustomThread t2 = new CustomThread("Worker2");

        System.out.println("Thread 1 name: " + t1.getName());
        System.out.println("Thread 2 name: " + t2.getName());

        t1.start();
        t2.start();
    }
}

2) Naming with setName() (Indirect Method)

class TaskThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " executing...");
    }
}

public class ThreadRenameDemo {
    public static void main(String[] args) {
        TaskThread thread1 = new TaskThread();
        TaskThread thread2 = new TaskThread();

        System.out.println("Initial Thread 1 name: " + thread1.getName());
        System.out.println("Initial Thread 2 name: " + thread2.getName());

        thread1.setName("TaskRunner1");
        thread2.setName("TaskRunner2");

        thread1.start();
        thread2.start();
    }
}

Fetching the Current Thread Name

public class CurrentThreadDemo {
    public static void main(String[] args) {
        System.out.println("Current thread: " + Thread.currentThread().getName());
    }
}

What Does start() Do?

Why start() instead of calling run()?

• start() creates a new thread and a new call stack
• JVM then calls run() on that new thread
• Calling run() directly runs on the same thread (no new thread created)

Example: run() vs start()

class CustomThread extends Thread {
    @Override
    public void run() {
        System.out.println("Executing on thread ID: " + Thread.currentThread().getId());
    }
}

public class RunVsStartDemo {
    public static void main(String[] args) {
        CustomThread t = new CustomThread();
        t.run();   // runs in main thread
        t.start(); // runs in a new thread
    }
}

Thread.sleep() in Java

sleep() pauses the current thread temporarily.

✅ Java provides two overloads:

1. Thread.sleep(long millis)
2. Thread.sleep(long millis, int nanos)

It throws InterruptedException.

Example 1: Using sleep() in Main Thread

public class MainThreadSleepExample {
    public static void main(String[] args) {
        try {
            for (int i = 1; i <= 4; i++) {
                Thread.sleep(2000);
                System.out.println("Iteration: " + i);
            }
        } catch (InterruptedException e) {
            System.out.println("Main thread interrupted: " + e);
        }
    }
}

Example 2: Using sleep() in a Custom Thread

class CustomThreadSleepExample extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 1; i <= 3; i++) {
                Thread.sleep(1000);
                System.out.println("Custom Thread Iteration: " + i);
            }
        } catch (InterruptedException e) {
            System.out.println("Custom thread interrupted: " + e);
        }
    }

    public static void main(String[] args) {
        new CustomThreadSleepExample().start();
    }
}

Example 3: Negative Sleep Time → IllegalArgumentException

public class NegativeSleepTimeExample {
    public static void main(String[] args) {
        try {
            Thread.sleep(-500);
        } catch (IllegalArgumentException e) {
            System.out.println("Caught IllegalArgumentException: Timeout value is negative");
        } catch (InterruptedException e) {
            System.out.println("Interrupted: " + e);
        }
    }
}

Exception in java

Exception Handling in Java is one of the effective means to manage runtime errors and preserve the regular flow of the application. Java’s mechanism for handling runtime errors like ClassNotFoundException, IOException, SQLException, and RemoteException ensures that exceptions are caught and handled appropriately.

What are Java Exceptions?

In Java, an Exception is an unwanted or unexpected event that occurs during the execution of a program, i.e., at runtime, which disrupts the normal flow of the program. Java provides mechanisms to catch and handle exceptions using the try-catch block. When an exception occurs, an exception object is created, containing information such as the name, description, and the program state at the time the exception occurred.

Major Reasons for Exceptions:

• Invalid user input
• Device failure
• Loss of network connection
• Out of disk memory
• Code errors
• Array index out of bounds
• Null reference
• Type mismatch
• Attempt to open an unavailable file
• Database errors
• Arithmetic errors (e.g., division by zero)

Errors like memory leaks, stack overflow, and out of memory are irrecoverable conditions typically beyond the control of the programmer. Errors should not be handled.

Difference between Error and Exception:

• Error: Represents a serious problem that the application should not attempt to catch.
• Exception: Indicates a condition that a reasonable application might attempt to catch and handle.

Exception Hierarchy

In Java, all exceptions and errors are subclasses of the Throwable class. The two branches are:

• Exception: User-defined and built-in exceptions such as NullPointerException.
• Error: System-level errors like StackOverflowError, indicating issues with the JVM.

Types of Exceptions

1. Built-in Exceptions: Java has a wide range of built-in exceptions divided into two categories:

• Checked Exceptions: These exceptions are checked at compile-time. Examples include IOException, SQLException.
• Unchecked Exceptions: These exceptions occur at runtime and are not checked during compilation. Examples include ArrayIndexOutOfBoundsException and NullPointerException.

2. User-Defined Exceptions: When built-in exceptions do not adequately describe an issue, Java allows for the creation of custom exceptions.

Example of Exception Handling Methods:

1. printStackTrace() Prints the name, description, and stack trace of the exception.

public class Main {
    public static void main(String[] args) {
        try {
            int a = 5;
            int b = 0;
            System.out.println(a / b);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }
}

Output:

java.lang.ArithmeticException: / by zero
at Main.main(Main.java:5)

2. toString() Prints the name and description of the exception.

public class Main {
    public static void main(String[] args) {
        try {
            int a = 5;
            int b = 0;
            System.out.println(a / b);
        } catch (ArithmeticException e) {
            System.out.println(e.toString());
        }
    }
}

Output:

java.lang.ArithmeticException: / by zero

3. getMessage() Prints only the description of the exception.

public class Main {
    public static void main(String[] args) {
        try {
            int a = 5;
            int b = 0;
            System.out.println(a / b);
        } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        }
    }
}

Output:

/ by zero

JVM Exception Handling Flow

When an exception occurs in a method, the method creates an Exception Object and passes it to the JVM. The JVM looks for an appropriate exception handler in the call stack, starting with the method where the exception occurred and moving backward. If no handler is found, the default exception handler terminates the program and prints the exception details.

Example of JVM Handling:

public class Main {
    public static void main(String[] args) {
        String str = null;
        System.out.println(str.length()); // NullPointerException
    }
}

Output:

Exception in thread "main" java.lang.NullPointerException
at Main.main(Main.java:4)

Programmer Handling Exception with Custom Code:

Using try, catch, finally, throw, and throws, Java allows programmers to handle exceptions gracefully.

Example:

public class Main {
    static int divideByZero(int a, int b) {
        return a / b;  // ArithmeticException if b is 0
    }

    static int computeDivision(int a, int b) {
        try {
            return divideByZero(a, b);
        } catch (NumberFormatException e) {
            System.out.println("NumberFormatException occurred");
            return 0;
        }
    }

    public static void main(String[] args) {
        try {
            int result = computeDivision(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Output:

Error: / by zero

Try-Catch Clause Usage Example:

public class Main {
    public static void main(String[] args) {
        int[] arr = new int[4];
        try {
            int value = arr[4]; // This will throw ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index is out of bounds.");
        }
        System.out.println("Program continues...");
    }
}

Output:

Array index is out of bounds.
Program continues...

Types of Exception in Java

Built-in Exceptions in Java

Java has several pre-defined exceptions that relate to its standard library classes. These exceptions help explain certain error conditions and can be caught and handled. Below are some important built-in exceptions:

• ArithmeticException: Thrown when an illegal arithmetic operation is performed, like division by zero.
• ArrayIndexOutOfBoundsException: Occurs when attempting to access an array with an invalid index, either negative or beyond the array’s length.
• ClassNotFoundException: Triggered when an application tries to load a class that cannot be found.
• FileNotFoundException: Raised when attempting to access a file that does not exist or is unavailable.
• IOException: Signals an issue with input-output operations, such as reading from a file.
• InterruptedException: Happens when a thread is interrupted during sleep, waiting, or performing certain tasks.
• NoSuchFieldException: Raised when trying to access a class field that does not exist.
• NoSuchMethodException: Raised when attempting to invoke a method that doesn’t exist.
• NullPointerException: Occurs when trying to call a method on an object reference that is null.
• NumberFormatException: Thrown when trying to convert a string into a number but the string is not a valid number.
• RuntimeException: Represents an error during program execution that is not checked at compile time.
• StringIndexOutOfBoundsException: Thrown when attempting to access characters outside of a string’s bounds.
• IllegalArgumentException: Raised when a method receives an inappropriate argument.
• IllegalStateException: Triggered when a method is invoked at an illegal or inappropriate time.

Examples of Built-in Exceptions

• ArithmeticException

class ArithmeticExceptionExample {
    public static void main(String[] args) {
        try {
            int num1 = 50, num2 = 0;
            int result = num1 / num2;  // Cannot divide by zero
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Division by zero is not allowed.");
        }
    }
}

Output:

Division by zero is not allowed.

• NullPointerException

class NullPointerExceptionExample {
    public static void main(String[] args) {
        try {
            String str = null;
            System.out.println(str.length()); // Null reference
        } catch (NullPointerException e) {
            System.out.println("Caught a NullPointerException.");
        }
    }
}

Output:

Caught a NullPointerException.

• StringIndexOutOfBoundsException

class StringIndexOutOfBoundsExceptionExample {
    public static void main(String[] args) {
        try {
            String sample = "Java is fun"; // Length is 11
            char ch = sample.charAt(15);   // Accessing out of bounds
        } catch (StringIndexOutOfBoundsException e) {
            System.out.println("String index out of bounds.");
        }
    }
}

Output:

String index out of bounds.

• FileNotFoundException

import java.io.*;

class FileNotFoundExceptionExample {
    public static void main(String[] args) {
        try {
            File file = new File("C://invalid_path.txt");
            FileReader reader = new FileReader(file);
        } catch (FileNotFoundException e) {
            System.out.println("The specified file is not found.");
        }
    }
}

Output:

The specified file is not found.

• NumberFormatException

class NumberFormatExceptionExample {
    public static void main(String[] args) {
        try {
            int number = Integer.parseInt("abc123");  // Invalid number format
        } catch (NumberFormatException e) {
            System.out.println("Invalid format for a number.");
        }
    }
}

Output:

Invalid format for a number.

• ArrayIndexOutOfBoundsException

class ArrayIndexOutOfBoundsExceptionExample {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3, 4, 5};
            System.out.println(numbers[6]);  // Invalid index access
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index is out of bounds.");
        }
    }
}

Output:

Invalid format for a number.

• ArrayIndexOutOfBoundsException

class ArrayIndexOutOfBoundsExceptionExample {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3, 4, 5};
            System.out.println(numbers[6]);  // Invalid index access
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index is out of bounds.");
        }
    }
}

Output:

Array index is out of bounds.

• IOException

import java.io.*;

class IOExceptionExample {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("nonexistentfile.txt"));
            String line = reader.readLine();
            System.out.println(line);
        } catch (IOException e) {
            System.out.println("Input-output error occurred.");
        }
    }
}

Output:

Input-output error occurred.

User-Defined Exceptions

In addition to built-in exceptions, Java allows developers to create custom exceptions that describe unique error situations.

Steps:

1. Create a class extending Exception.
2. Write a constructor that passes a message to the Exception class.
3. Use throw to raise this custom exception in your program.

Example of User-Defined Exception

class LowBalanceException extends Exception {
    LowBalanceException(String message) {
        super(message);
    }
}

class CustomExceptionExample {
    public static void main(String[] args) {
        double balance = 400.00;
        try {
            checkBalance(balance);
        } catch (LowBalanceException e) {
            System.out.println(e.getMessage());
        }
    }

    static void checkBalance(double balance) throws LowBalanceException {
        if (balance < 500) {
            throw new LowBalanceException("Balance is below the minimum threshold!");
        } else {
            System.out.println("Your balance is sufficient.");
        }
    }
}

Output:

Balance is below the minimum threshold!

Checked vs Unchecked Exceptions in Java

In Java, an exception is an event that disrupts the normal flow of a program during its execution. Java categorizes exceptions into two types:

1. Checked Exceptions:

These exceptions are checked at compile time. If a method throws a checked exception, it must either handle the exception using a try-catch block or declare it using the throws keyword. Checked exceptions typically occur in scenarios that are beyond the control of the program, such as reading from a file or a network issue.

Example of a Checked Exception:

import java.io.*;

public class CheckedExceptionDemo {
    public static void main(String[] args) throws IOException {
        // Trying to read from a non-existing file
        FileReader fileReader = new FileReader("D:\\data.txt");
        BufferedReader bufferedReader = new BufferedReader(fileReader);

        // Reading the first three lines of the file
        for (int i = 0; i < 3; i++) {
            System.out.println(bufferedReader.readLine());
        }

        // Closing the file reader
        bufferedReader.close();
    }
}

Output:

Exception in thread "main" java.io.FileNotFoundException: D:\data.txt (The system cannot find the file specified)
at java.io.FileInputStream.open0(Native Method)
at java.io.FileInputStream.open(FileInputStream.java:195)
...

2. Unchecked Exceptions:

These exceptions are not checked at compile time. They are usually caused by programming errors like trying to access an array out of bounds or dividing by zero. Unchecked exceptions are derived from RuntimeException. Unlike checked exceptions, you are not required to handle or declare them in your method signature.

Example of an Unchecked Exception:

public class UncheckedExceptionDemo {
    public static void main(String[] args) {
        // Dividing by zero will cause ArithmeticException
        int a = 5;
        int b = 0;
        int result = a / b;  // This will throw an exception
    }
}

Output:

Exception in thread "main" java.lang.ArithmeticException: / by zero
at UncheckedExceptionDemo.main(UncheckedExceptionDemo.java:5)

Here, ArithmeticException is an unchecked exception that occurs at runtime due to division by zero.

Other Examples of Checked and Unchecked Exceptions:

1. Checked Exception – Handling with throws:

import java.io.*;

public class HandleCheckedException {
    public static void main(String[] args) throws IOException {
        FileReader reader = new FileReader("D:\\info.txt");
        BufferedReader bufferedReader = new BufferedReader(reader);

        System.out.println(bufferedReader.readLine());

        bufferedReader.close();
    }
}

Output:

Exception in thread "main" java.io.FileNotFoundException: D:\info.txt (The system cannot find the file specified)

2. Unchecked Exception – NullPointerException:

public class NullPointerExceptionDemo {
    public static void main(String[] args) {
        String data = null;
        System.out.println(data.length());  // This will cause a NullPointerException
    }
}

Output:

Exception in thread "main" java.lang.NullPointerException
at NullPointerExceptionDemo.main(NullPointerExceptionDemo.java:5)

3. Unchecked Exception – ArrayIndexOutOfBoundsException:

public class ArrayIndexOutOfBoundsExceptionDemo {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3};
        System.out.println(numbers[5]);  // This will throw ArrayIndexOutOfBoundsException
    }
}

Output:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
at ArrayIndexOutOfBoundsExceptionDemo.main(ArrayIndexOutOfBoundsExceptionDemo.java:5)

Java Try Catch Block

In Java, an exception is an “undesirable or unexpected event” that occurs during the program’s execution, causing it to terminate unexpectedly. To prevent this abrupt termination, Java provides mechanisms like the try-catch block for handling exceptions. In this explanation, we will discuss the usage of try, catch, throw, throws, and finally in Java.

Reasons Why an Exception May Occur:

An exception can be triggered by multiple factors such as:

• Issues with network connectivity
• Incorrect input from the user
• Attempting to open a file that doesn’t exist, etc.

Exception Handling Constructs and Keywords:

1. try Block : The try block encompasses the code that may potentially cause an exception. If an exception occurs in this block, it is transferred to the corresponding catch block.

try {
    // code that might generate an exception
}

2. catch Block: The catch block handles exceptions thrown by the try block. It is always placed after the try block to process any exceptions that occur.

catch (Exception e) {
    // code to handle the exception
    // e.g., closing resources, logging errors
}

3. throw Keyword: The throw keyword explicitly throws an exception, typically used to pass control from a try block to the catch block. It is often used when custom exceptions need to be raised.

Example:

// Java program demonstrating the use of throw
class CustomExceptionExample {
    static void demonstrateThrow() {
        try {
            throw new IllegalArgumentException("Invalid argument");
        } catch (IllegalArgumentException e) {
            System.out.println("Caught in demonstrateThrow().");
            throw e;  // rethrowing the exception
        }
    }

    public static void main(String[] args) {
        try {
            demonstrateThrow();
        } catch (IllegalArgumentException e) {
            System.out.println("Caught in main with message:");
            System.out.println(e);
        }
    }
}

Output:

Caught in demonstrateThrow().
Caught in main with message:
java.lang.IllegalArgumentException: Invalid argument

4. throws Keyword: The throws keyword is used to declare exceptions in a method signature without handling them within the method itself. This allows the calling method to handle the exception instead.

Example:

// Java program demonstrating throws
class ThrowsDemo {
    // This method declares an exception
    static void riskyMethod() throws IllegalStateException {
        System.out.println("Inside riskyMethod.");
        throw new IllegalStateException("Critical error");
    }

    public static void main(String[] args) {
        try {
            riskyMethod();
        } catch (IllegalStateException e) {
            System.out.println("Caught in main.");
        }
    }
}

Output:

Inside riskyMethod.
Caught in main.

5. finally Block: The finally block is always executed after the try-catch blocks, regardless of whether an exception was thrown or not. It is typically used for code that needs to execute no matter what, such as closing resources.

Example:

// Java program demonstrating try, catch, and finally
class FinalBlockExample {
    public static void main(String[] args) {
        int num1 = 20, num2 = 10, num3 = 10, result;

        try {
            result = num1 / (num2 - num3);  // Will cause division by zero
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Exception caught: Division by zero");
        } finally {
            System.out.println("This is the finally block.");
        }
    }
}

Output:

Exception caught: Division by zero
This is the finally block.

Flow control in try catch finally in Java

In this article, we will explore all the possible combinations of try-catch-finally blocks and how control flow behaves when an exception is thrown. We’ll cover different cases that can arise, such as exceptions being caught, not caught, and cases where no exception occurs.

Control Flow in try-catch or try-catch-finally Blocks:

Exception Occurs in try Block and Is Handled in catch Block

When an exception occurs in the try block, the remaining code in that block will not be executed. The control is passed to the corresponding catch block, where the exception is handled. After the catch block, if a finally block exists, it will execute, and then the rest of the program will continue.

Control Flow Example with try-catch:

// Java program to demonstrate control flow
// when an exception occurs in the try block
// and is handled in the catch block
class Example1 {
    public static void main(String[] args) {
        int[] arr = new int[4];
        try {
            int i = arr[4];  // Exception occurs here
            System.out.println("Inside try block");
        } catch (ArrayIndexOutOfBoundsException ex) {
            System.out.println("Exception caught in catch block");
        }
        System.out.println("Outside try-catch block");
    }
}

Output:

Exception caught in catch block
Outside try-catch block

Control Flow Example with try-catch-finally:

// Java program to demonstrate control flow
// with try-catch-finally when an exception occurs
class Example2 {
    public static void main(String[] args) {
        int[] arr = new int[4];
        try {
            int i = arr[4];  // Exception occurs here
            System.out.println("Inside try block");
        } catch (ArrayIndexOutOfBoundsException ex) {
            System.out.println("Exception caught in catch block");
        } finally {
            System.out.println("finally block executed");
        }
        System.out.println("Outside try-catch-finally block");
    }
}

Output:

Exception caught in catch block
finally block executed
Outside try-catch-finally block

Control Flow in try-finally:

In the try-finally block, the finally block always executes, regardless of whether an exception occurs or not. The control flow differs depending on whether an exception is raised.

Exception Occurs in try Block

// Java program to demonstrate control flow
// when an exception occurs in try-finally block
class Example7 {
    public static void main(String[] args) {
        int[] arr = new int[4];
        try {
            int i = arr[4];  // Exception occurs here
            System.out.println("Inside try block");
        } finally {
            System.out.println("finally block executed");
        }
        System.out.println("Outside try-finally block");
    }
}

Output:

finally block executed
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4

throw and throws in Java

In Java, exception handling is a crucial mechanism to manage runtime errors, ensuring that the normal flow of a program isn’t interrupted. Common exceptions include ClassNotFoundException, IOException, SQLException, and RemoteException, among others.

This article will delve into two essential components of exception handling in Java: the throw and throws keywords, explaining their use and providing practical examples.

Java throw

The throw keyword is used to explicitly raise an exception from a method or block of code. Both checked and unchecked exceptions can be thrown using throw, and it is especially useful for raising custom exceptions.

Syntax:

throw instance;

Where instance is an object of type Throwable or its subclass. For example, Exception is a subclass of Throwable, and user-defined exceptions generally extend the Exception class. Unlike languages like C++, Java does not allow basic data types (like int or char) or non-throwable classes to be used as exceptions.

When a throw statement is executed, the program’s control flow is immediately transferred to the nearest enclosing try-catch block that can handle the exception. If no matching catch block is found, the program terminates with an error.

Java throw Examples
Example 1:

// Java program to demonstrate the use of throw
class CustomThrowExample {
    static void checkException() {
        try {
            throw new IllegalArgumentException("Demo Exception");
        } catch (IllegalArgumentException e) {
            System.out.println("Caught inside checkException().");
            throw e;  // rethrowing the exception
        }
    }

    public static void main(String[] args) {
        try {
            checkException();
        } catch (IllegalArgumentException e) {
            System.out.println("Caught in main.");
        }
    }
}

Output:

Caught inside checkException().
Caught in main.

User-defined Custom Exception

In Java, an exception is a runtime issue that interrupts the normal execution flow of a program. When an exception occurs, the program is terminated unexpectedly, and any code following the exception-generating statement is not executed.

Java allows developers to create their own exceptions, which are subclasses of the Exception class. This is referred to as a custom exception or user-defined exception. Custom exceptions are primarily used to suit specific requirements by adding custom error-handling logic.

For instance, in the following example, the class CustomException extends the Exception class to create a new custom exception.

Why Use Custom Exceptions?

While Java provides a wide range of built-in exceptions, there are scenarios where custom exceptions are beneficial. Below are some reasons for creating custom exceptions:

1.Specific Exception Handling: Custom exceptions can target a specific subset of existing exceptions, allowing more refined exception handling.
Business Logic Exceptions: Custom exceptions are useful for handling business logic errors, making it easier for developers and users to understand the nature of the problem in the workflow.

To define a custom exception, you need to extend the Exception class, which is part of the java.lang package.

Example:

// A class representing a user-defined exception
class CustomException extends Exception {
    public CustomException(String message) {
        // Call the constructor of the parent Exception class
        super(message);
    }
}

// A class that uses the CustomException
public class MainApp {
    // Main method
    public static void main(String[] args) {
        try {
            // Throw an instance of the custom exception
            throw new CustomException("Custom exception occurred");
        } catch (CustomException e) {
            System.out.println("Exception caught");

            // Print the message from the CustomException object
            System.out.println(e.getMessage());
        }
    }
}

Output:

Exception caught
Custom exception occurred

Chained Exceptions in Java

Chained Exceptions in Java allow developers to associate one exception with another, establishing a relationship between them. This is helpful when one exception is a direct result of another. For instance, imagine a scenario where a method throws an ArithmeticException due to division by zero, but the real cause was an I/O error that led to the divisor being zero. In such a case, only the ArithmeticException would be reported, making it difficult for the caller to understand the root cause. Chained Exceptions solve this problem by allowing the original exception to be linked with the final exception.

Constructors in the Throwable Class Supporting Chained Exceptions:

1.Throwable(Throwable cause): Accepts the cause of the current exception as an argument.

2. Throwable(String msg, Throwable cause):Takes a custom error message (msg) and the cause (cause) as arguments.

Methods in the Throwable Class Supporting Chained Exceptions:

1. getCause():Retrieves the original cause of the exception.

2. initCause(Throwable cause):Allows setting the cause for the current exception.

Example of Chained Exception Usage:

// Java program demonstrating chained exceptions
public class ChainedExceptionDemo {
    public static void main(String[] args) {
        try {
            // Create a new ArithmeticException
            ArithmeticException ex = new ArithmeticException("Arithmetic error occurred");

            // Set the cause of this exception to an I/O-related issue
            ex.initCause(new IllegalStateException("Caused by a file error"));

            // Throw the exception
            throw ex;
        } catch (ArithmeticException ex) {
            // Display the exception message
            System.out.println(ex);

            // Retrieve and display the actual cause of the exception
            System.out.println("Caused by: " + ex.getCause());
        }
    }
}

Output:

java.lang.ArithmeticException: Arithmetic error occurred
Caused by: java.lang.IllegalStateException: Caused by a file error

finally block executed
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4

What is a Package?

A package in Java is a namespace that groups related classes, interfaces, subpackages, enums, and annotations. Packages help organize large projects and provide modularity.

Why Use Packages?

Packages provide several important benefits:

1. Avoid name conflicts
   Example:
   university.department.cs.Student
university.department.ee.Student
2. Better organization
   Related classes are grouped logically.
3. Access control
   • protected: accessible within the same package and subclasses
   • default (no modifier): accessible only within the same package
4. Encapsulation (data hiding)
   Internal implementation can be hidden while exposing public APIs.
5. Reusability
   Classes from packages can be reused across applications.

How Packages Work

Package names map directly to directory structures.

Example:

package university.department.cs;

Directory structure:

university/
 └── department/
     └── cs/

Java uses the CLASSPATH to locate packages and classes at runtime.

Package Naming Conventions

Java package names usually follow reverse domain naming:

com.company.project.module
org.organization.application
university.department.math

This guarantees global uniqueness.

Adding Classes to a Package

To add a class to a package:

1. Declare the package at the top of the file
2. Save the file in the corresponding directory
3. Compile the file

package mypack;

public class MyClass {
    public void display() {
        System.out.println("Hello from MyClass in mypack.");
    }
}

Subpackages

A subpackage is a package inside another package.

java.util
java.util.concurrent

⚠️ Subpackages are not automatically imported with parent packages.

import java.util.*;          // Does NOT import java.util.concurrent

Importing Packages

Import a Specific Class

import java.util.ArrayList;

Import All Classes from a Package

import java.util.*;

Subpackages are excluded.

Accessing Classes in a Package

import java.util.List;

public class DemoImport {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();

        java.util.LinkedList<String> items =
                new java.util.LinkedList<>();
    }
}

Types of Packages in Java

1. Built-in Packages

Provided by Java API.

Common examples:

• java.lang
• java.util
• java.io
• java.net
• java.awt

2. User-Defined Packages

// File: mypack/MyClass.java
package mypack;

public class MyClass {
    public void display() {
        System.out.println("Hello from MyClass in mypack.");
    }
}

Usage:

import mypack.MyClass;

public class TestPackage {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.display();
    }
}

Output

Hello from MyClass in mypack.

Creating a Package (Compile & Run)

package myPackage;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello from myPackage!");
    }
}

Compile

javac -d . HelloWorld.java

Run

java myPackage.HelloWorld

Static Import in Java

Static import allows direct access to static members without class name.

import static java.lang.Math.*;

public class StaticImportExample {
    public static void main(String[] args) {
        System.out.println(PI);
        System.out.println(sqrt(16));
    }
}

Handling Name Conflicts

When two packages contain classes with the same name, use fully qualified names.

import java.util.Date;
import java.sql.*;

public class ConflictExample {
    public static void main(String[] args) {
        java.util.Date utilDate = new java.util.Date();
        java.sql.Date sqlDate =
                new java.sql.Date(System.currentTimeMillis());

        System.out.println(utilDate);
        System.out.println(sqlDate);
    }
}

Directory Structure Mapping

com.example.shapes.Circle
↓
BASE_DIR/com/example/shapes/Circle.class

Important Built-in Packages

java.util Package

Provides utility classes for:

• Collections
• Date & time
• Random numbers
• Locale & formatting
• Timers

Example

import java.util.ArrayList;

public class Example {
    public static void main(String[] args) {
        ArrayList<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        System.out.println(fruits);
    }
}

java.lang Package

Automatically imported in every Java program.

Key classes:

• Object
• String
• Math
• System
• Thread
• Wrapper classes (Integer, Double, etc.)

Eg:

public class Example {
    public static void main(String[] args) {
        String msg = "Hello Java";
        System.out.println(msg.length());
    }
}

java.io Package

Handles:

• File input/output
• Streams
• Serialization
• Buffered I/O

Example: File Copy

import java.io.*;

public class FileCopyExample {
    public static void main(String[] args) {
        try (FileInputStream in = new FileInputStream("source.txt");
             FileOutputStream out = new FileOutputStream("dest.txt")) {

            int data;
            while ((data = in.read()) != -1) {
                out.write(data);
            }
            System.out.println("File copied successfully");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Buffered Reader & Writer Example

import java.io.*;

public class BufferedExample {
    public static void main(String[] args) {
        try (BufferedReader reader =
                     new BufferedReader(new FileReader("input.txt"));
             BufferedWriter writer =
                     new BufferedWriter(new FileWriter("output.txt"))) {

            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
            System.out.println("File processed successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Summary

• Packages organize Java code logically
• Prevent naming conflicts
• Improve encapsulation and security
• Support modular, reusable development
• Java provides rich built-in packages
• Developers can create custom packages easily