Category:

Tutorials

Java FileReader Class tutorial with Examples

written by 75ypsaw71

The FileReader class in Java is used to read character-based data from files.

It is part of the java.io package and allows you to read data from a file character by character, line by line, or into an array.

FileReader is especially useful for reading text files, as it can handle files with character data efficiently.

In this tutorial, we will cover:

Table of Contents

Let’s explore each topic with examples.

1. Basic Usage of FileReader

The FileReader class has constructors to open a file and prepare it for reading.

If the file does not exist, it throws a FileNotFoundException.

Example 1: Reading a File with FileReader

import java.io.FileReader;
import java.io.IOException;

public class BasicFileReaderExample {
    public static void main(String[] args) {
        try {
            // Create a FileReader instance to read "example.txt"
            FileReader reader = new FileReader("example.txt");

            // Read each character until the end of the file
            int character;
            while ((character = reader.read()) != -1) {
                System.out.print((char) character);
            }

            // Close the FileReader
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation: This example reads the file example.txt character by character. The read() method returns the ASCII integer value of each character, which is then cast to char for display. When it reaches the end, it returns -1.

2. Reading a File Character by Character

Reading character by character can be helpful when processing text data in a specific format or when looking for specific characters within the file.

Example 2: Reading Character by Character

import java.io.FileReader;
import java.io.IOException;

public class ReadCharacterByCharacterExample {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("characters.txt")) {
            int charData;
            while ((charData = reader.read()) != -1) {
                System.out.print((char) charData);  // Print each character
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation: Here, we use a while loop to read each character until the end of the file (-1). The file is closed automatically with the try-with-resources statement.

3. Reading a File into a Character Array

FileReader can read data into a character array, which is more efficient than reading one character at a time, especially for larger files.

Example 3: Reading a File into a Character Array

import java.io.FileReader;
import java.io.IOException;

public class ReadIntoCharArrayExample {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("example.txt")) {
            // Create a character array to store data
            char[] buffer = new char[100];
            int numCharsRead;

            // Read characters into the buffer array
            while ((numCharsRead = reader.read(buffer)) != -1) {
                System.out.print(new String(buffer, 0, numCharsRead));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation: In this example, data is read into a buffer array. The read(buffer) method returns the number of characters read into the buffer, which may be less than the array length if the file ends early.

4. Using BufferedReader with FileReader for Line-by-Line Reading

For efficient line-by-line reading, use BufferedReader with FileReader.

BufferedReader provides the readLine() method, which reads a line of text as a string.

Example 4: Reading a File Line by Line

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderExample {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("example.txt");
             BufferedReader bufferedReader = new BufferedReader(reader)) {

            String line;
            while ((line = bufferedReader.readLine()) != null) {
                System.out.println(line);  // Print each line
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation: BufferedReader reads one line at a time using readLine(), which is more efficient for text files than reading character by character. It stops reading when readLine() returns null, indicating the end of the file.

5. Handling Exceptions and Closing FileReader

Always close FileReader after reading, either explicitly by calling close() or using try-with-resources for automatic closure, which prevents memory leaks.

Example 5: Reading a File with try-with-resources

import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesFileReaderExample {
    public static void main(String[] args) {
        // Use try-with-resources to automatically close FileReader
        try (FileReader reader = new FileReader("resources.txt")) {
            int data;
            while ((data = reader.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation: This example uses try-with-resources to automatically close the FileReader once reading is complete, ensuring that resources are released.

Summary of Key FileReader Concepts

Feature	Description
Basic Reading	Reads a file character by character; read() returns -1 when end of file is reached.
Character Array Reading	Reads multiple characters into a buffer array for efficient processing.
Line-by-Line Reading	Use BufferedReader with FileReader to read files line by line.
Exception Handling	Handles IOException and uses try-with-resources for automatic resource management.

Conclusion

In this tutorial, we covered various ways to use the FileReader class in Java:

Basic reading with FileReader character by character.
Reading data into a character array for efficient processing.
Reading files line by line using BufferedReader.
Using try-with-resources to manage resources automatically.

October 25, 2024 0 comment

File

Java FileWriter Class Tutorial with Examples

written by 75ypsaw71

The FileWriter class in Java is used to write character-based data to files.

It is part of the java.io package and provides methods to write text data to files.

FileWriter is particularly useful when you need to create or update a text file with custom content.

In this tutorial, we will cover:

Basic Usage of FileWriter
Appending Data to an Existing File
Writing Characters and Strings
Using BufferedWriter with FileWriter
Handling Exceptions and Closing FileWriter

Let’s go through each section with examples.

1. Basic Usage of FileWriter

The FileWriter class has constructors to create a new file or to open an existing file for writing.

If the file does not exist, it creates it; if it does exist, it overwrites the file unless set otherwise.

Example 1: Writing a Simple Message to a File

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

public class BasicFileWriterExample {
    public static void main(String[] args) {
        try {
            // Create a FileWriter instance to write to "example.txt"
            FileWriter writer = new FileWriter("example.txt");
            
            // Write a simple message
            writer.write("Hello, World!");
            
            // Close the FileWriter
            writer.close();
            System.out.println("Successfully wrote to the file.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation: This example creates a new file named example.txt (if it doesn’t exist) and writes the message “Hello, World!” into it. After writing, it closes the FileWriter to release resources.

2. Appending Data to an Existing File

By default, FileWriter overwrites the file.

However, you can append to an existing file by using the FileWriter constructor with true as the second parameter.

Example 2: Appending Text to a File

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

public class AppendFileWriterExample {
    public static void main(String[] args) {
        try {
            // Create a FileWriter in append mode
            FileWriter writer = new FileWriter("example.txt", true);
            
            // Append a message to the file
            writer.write("\nThis is an appended line.");
            
            // Close the FileWriter
            writer.close();
            System.out.println("Successfully appended to the file.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation: Here, true in new FileWriter(“example.txt”, true) opens the file in append mode, so it adds new content instead of overwriting the file.

3. Writing Characters and Strings

You can write individual characters, arrays of characters, or entire strings to a file using FileWriter.

Example 3: Writing Individual Characters

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

public class WriteCharactersExample {
    public static void main(String[] args) {
        try {
            FileWriter writer = new FileWriter("characters.txt");

            // Writing individual characters
            writer.write('H');
            writer.write('e');
            writer.write('l');
            writer.write('l');
            writer.write('o');

            writer.close();
            System.out.println("Successfully wrote characters to the file.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Example 4: Writing an Array of Characters

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

public class WriteCharArrayExample {
    public static void main(String[] args) {
        try {
            FileWriter writer = new FileWriter("charArray.txt");

            // Write an array of characters
            char[] message = {'H', 'e', 'l', 'l', 'o', ' ', 'J', 'a', 'v', 'a'};
            writer.write(message);

            writer.close();
            System.out.println("Successfully wrote a character array to the file.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Example 5: Writing an Entire String

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

public class WriteStringExample {
    public static void main(String[] args) {
        try {
            FileWriter writer = new FileWriter("string.txt");

            // Write a full string
            writer.write("This is a string being written to the file!");

            writer.close();
            System.out.println("Successfully wrote a string to the file.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. Using BufferedWriter with FileWriter

For efficient writing, especially for large files, use BufferedWriter along with FileWriter.

BufferedWriter buffers the data, reducing the number of write operations to the disk.

Example 6: Using BufferedWriter for Buffered Writing

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

public class BufferedWriterExample {
    public static void main(String[] args) {
        try {
            // Create FileWriter and BufferedWriter
            FileWriter writer = new FileWriter("buffered.txt");
            BufferedWriter bufferedWriter = new BufferedWriter(writer);

            // Write multiple lines
            bufferedWriter.write("First line of text");
            bufferedWriter.newLine();  // Add a new line
            bufferedWriter.write("Second line of text");
            bufferedWriter.newLine();
            bufferedWriter.write("Third line of text");

            // Close the BufferedWriter and FileWriter
            bufferedWriter.close();
            writer.close();
            System.out.println("Successfully wrote to the file using BufferedWriter.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation: BufferedWriter buffers the output, minimizing I/O operations. Here, newLine() is used to add line breaks between lines.

5. Handling Exceptions and Closing FileWriter

Always close the FileWriter after writing to release system resources.

It’s recommended to use a try-with-resources statement to automatically close the FileWriter, which avoids potential memory leaks.

Example 7: Writing to a File with try-with-resources

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

public class TryWithResourcesExample {
    public static void main(String[] args) {
        // Use try-with-resources to auto-close FileWriter
        try (FileWriter writer = new FileWriter("resources.txt")) {
            writer.write("This file is written using try-with-resources.");
            System.out.println("Successfully wrote to the file with try-with-resources.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation: The try-with-resources statement automatically closes FileWriter at the end of the try block, eliminating the need for a separate close() call.

Summary of Key FileWriter Concepts

Feature	Description
Basic Writing	Creates a new file or overwrites existing content.
Append Mode	Use new FileWriter(filename, true) to append instead of overwrite.
Writing Characters	Write individual characters, character arrays, or strings.
Buffered Writing	Use BufferedWriter to improve writing performance for large files.
Auto-Close with try-with-resources	Ensures FileWriter is closed automatically, preventing memory leaks.

Conclusion

In this tutorial, we explored various ways to use the FileWriter class in Java, including:

Basic file writing operations.
Appending content to an existing file.
Writing individual characters, arrays, and entire strings.
Buffered writing with BufferedWriter for enhanced performance.
Exception handling and safe closure using try-with-resources.

October 25, 2024 0 comment

OOP

Java Access Modifiers Tutorial with Examples

written by 75ypsaw71

In Java, access modifiers control the visibility and accessibility of classes, methods, and variables. They are an essential part of encapsulation, which is one of the key principles of Object-Oriented Programming (OOP).

Java provides four types of access modifiers:

Private: Accessible only within the same class.
Default (Package-private): Accessible only within the same package.
Protected: Accessible within the same package and also in subclasses.
Public: Accessible from everywhere.

In this tutorial, we will cover:

Let’s dive into each type of access modifier with examples!

1. What are Access Modifiers?

Access modifiers in Java define how the members (variables, methods, constructors) and classes themselves can be accessed. They control visibility and ensure that sensitive data or behavior is encapsulated within a class or a package.

The Four Types of Access Modifiers:

Private: Restricted to the same class.
Default (Package-private): Accessible only within the same package. (No explicit keyword is used.)
Protected: Accessible within the same package and by subclasses (even in different packages).
Public: Accessible from any other class.

2. Private Access Modifier

The private access modifier makes a member visible only within its own class. No other class can access this member, even if they are in the same package.

Example: Private Access Modifier

class PrivateExample {
    private String secretMessage = "This is private";

    private void showSecret() {
        System.out.println(secretMessage);
    }

    public void publicMethod() {
        System.out.println("Public method called.");
        showSecret();  // Private method accessed inside the class
    }
}

public class Main {
    public static void main(String[] args) {
        PrivateExample obj = new PrivateExample();
        obj.publicMethod();  // Output: Public method called. This is private.

        // Below lines will throw errors because secretMessage and showSecret() are private
        // System.out.println(obj.secretMessage);  // Error
        // obj.showSecret();  // Error
    }
}

Explanation:

The variable secretMessage and the method showSecret() are marked as private and can only be accessed within the PrivateExample class.
The publicMethod() method can call the private method because it is inside the same class.

3. Default (Package-private) Access Modifier

If no access modifier is specified, Java applies default access (also known as package-private access). Members with default access are accessible by any class within the same package but not from other packages.

Example: Default Access Modifier (Package-private)

// Inside package "mypackage"
package mypackage;

class DefaultExample {
    String defaultMessage = "This is default access";

    void showMessage() {
        System.out.println(defaultMessage);
    }
}

// Inside the same package "mypackage"
package mypackage;

public class MainInSamePackage {
    public static void main(String[] args) {
        DefaultExample obj = new DefaultExample();
        obj.showMessage();  // Output: This is default access
    }
}

// Inside a different package "otherpackage"
package otherpackage;

import mypackage.DefaultExample;

public class MainInOtherPackage {
    public static void main(String[] args) {
        DefaultExample obj = new DefaultExample();
        // obj.showMessage();  // Error: showMessage() has package-private access
    }
}

Explanation:

The defaultMessage variable and the showMessage() method are package-private, meaning they can only be accessed within the mypackage package.
Trying to access them from a class in the otherpackage package will result in an error.

4. Protected Access Modifier

The protected access modifier allows access to members within the same package and to subclasses (even if the subclasses are in a different package).

Example: Protected Access Modifier

// Inside package "mypackage"
package mypackage;

public class Animal {
    protected String sound = "Generic animal sound";

    protected void makeSound() {
        System.out.println(sound);
    }
}

// Inside a subclass in the same package "mypackage"
package mypackage;

public class Dog extends Animal {
    public void dogBark() {
        System.out.println("Dog barks");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();  // Output: Generic animal sound (inherited from Animal)
        dog.dogBark();    // Output: Dog barks
    }
}

// Inside a subclass in a different package "otherpackage"
package otherpackage;

import mypackage.Animal;

public class Cat extends Animal {
    public void catMeow() {
        System.out.println("Cat meows");
        System.out.println("Animal sound: " + sound);  // Accessing protected member
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound();  // Output: Generic animal sound (inherited)
        cat.catMeow();    // Output: Cat meows. Animal sound: Generic animal sound
    }
}

Explanation:

The sound variable and makeSound() method are declared as protected in the Animal class.
They are accessible in the subclass Dog in the same package and the subclass Cat in a different package (otherpackage).

5. Public Access Modifier

The public access modifier allows a class, method, or variable to be accessible from anywhere. If a member is marked as public, there are no restrictions on its visibility.

Example: Public Access Modifier

// Inside package "mypackage"
package mypackage;

public class PublicExample {
    public String message = "This is public";

    public void showMessage() {
        System.out.println(message);
    }
}

// Inside any package (even outside "mypackage")
package otherpackage;

import mypackage.PublicExample;

public class Main {
    public static void main(String[] args) {
        PublicExample obj = new PublicExample();
        obj.showMessage();  // Output: This is public
    }
}

Explanation:

The message variable and showMessage() method are declared as public, making them accessible from any class in any package.
The class PublicExample itself is also declared as public, so it can be imported and used in the otherpackage package.

6. Access Modifiers with Classes

In Java, top-level classes can only have public or default (package-private) access. A public class can be accessed from any package, while a class with default access is only accessible within the same package.

Example: Access Modifiers with Classes

// Inside package "mypackage"
package mypackage;

// Default access class (Package-private)
class DefaultClass {
    public void display() {
        System.out.println("Default access class method.");
    }
}

// Public access class
public class PublicClass {
    public void display() {
        System.out.println("Public class method.");
    }
}

// In a different package "otherpackage"
package otherpackage;

import mypackage.PublicClass;

public class Main {
    public static void main(String[] args) {
        PublicClass publicObj = new PublicClass();
        publicObj.display();  // Output: Public class method.

        // DefaultClass defaultObj = new DefaultClass();  // Error: DefaultClass is not public
    }
}

Explanation:

The PublicClass is declared public, so it can be accessed from anywhere.
The DefaultClass is package-private, so it can only be accessed within the mypackage package, and trying to access it from otherpackage results in an error.

Summary of Java Access Modifiers

Modifier	Class	Within Package	Subclass (Different Package)	Other Packages
private	Same class only	Not accessible	Not accessible	Not accessible
default	Same package only	Accessible	Not accessible	Not accessible
protected	Same package + subclasses	Accessible	Accessible in subclass	Not accessible
public	Accessible everywhere	Accessible everywhere	Accessible everywhere	Accessible everywhere

7. Examples and Use Cases

Example 1: Using protected in Inheritance

package mypackage;

public class Vehicle {
    protected int speed = 100;

    protected void showSpeed() {
        System.out.println("Speed: " + speed);
    }
}

package otherpackage;

import mypackage.Vehicle;

public class Car extends Vehicle {
    public void displaySpeed() {
        showSpeed();  // Accessing protected method
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.displaySpeed();  // Output: Speed: 100
    }
}

Example 2: Restricting Access with private

class Account {
    private double balance = 5000;

    // Private method
    private void updateBalance(double amount) {
        balance += amount;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            updateBalance(amount);  // Private method can be accessed inside the class
            System.out.println("Deposited " + amount);
        }
    }

    public double getBalance() {
        return balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        account.deposit(500);  // Output: Deposited 500
        System.out.println("Balance: " + account.getBalance());  // Output: Balance: 5500

        // account.updateBalance(100);  // Error: updateBalance() is private
    }
}

Conclusion

In Java, access modifiers are essential for controlling the visibility and accessibility of classes, methods, and variables. They are fundamental in implementing encapsulation, one of the four principles of Object-Oriented Programming (OOP). In this tutorial, we covered:

Private access for ensuring that methods and variables are only accessible within the same class.
Default access for restricting access to members within the same package.
Protected access for allowing access within the same package and to subclasses.
Public access for allowing unrestricted access to members.

October 21, 2024 0 comment

OOP

Java Instance Initializer Block Tutorial with Examples

written by 75ypsaw71

In Java, an Instance Initializer Block (IIB) is a block of code that is executed whenever an object of the class is created.

It allows us to initialize instance variables or perform actions that need to be executed each time a new object is instantiated, regardless of the constructor used.

The block runs before the constructor and after instance variables are initialized.

In this tutorial, we will cover:

What is an Instance Initializer Block?
Basic Syntax of Instance Initializer Block
Why Use Instance Initializer Blocks?
Order of Execution: IIB vs Constructor
Multiple Instance Initializer Blocks
Examples and Use Cases

Let’s explore each concept with examples!

1. What is an Instance Initializer Block?

An Instance Initializer Block (IIB) is a block of code enclosed in curly braces {} that is executed before the constructor and is used to initialize instance variables or perform any initialization logic. It gets executed every time an object is created.

Key Characteristics:

It is executed before the constructor.
It can be used for shared initialization among constructors.
It runs each time an instance is created.

2. Basic Syntax of Instance Initializer Block

The syntax for an Instance Initializer Block is straightforward. You simply define a block of code with curly braces {} outside any methods or constructors in the class.

Example 1: Basic Instance Initializer Block

class Example {
    // Instance variable
    int value;

    // Instance Initializer Block
    {
        value = 10;
        System.out.println("Instance Initializer Block executed, value set to " + value);
    }

    // Constructor
    public Example() {
        System.out.println("Constructor executed.");
    }
}

public class InstanceInitializerExample {
    public static void main(String[] args) {
        Example obj = new Example();
        // Output:
        // Instance Initializer Block executed, value set to 10
        // Constructor executed.
    }
}

Explanation:

The Instance Initializer Block sets the value of the value variable to 10.
The block is executed before the constructor, and the constructor is executed afterward.

3. Why Use Instance Initializer Blocks?

Instance Initializer Blocks are useful when:

Multiple constructors share common initialization code. Instead of duplicating the initialization logic in each constructor, you can put it in an IIB.
You need to perform complex initialization that can’t be done in field initializations or constructor parameters.
You want to ensure certain code is always executed, regardless of which constructor is used.

Example 2: Shared Initialization Code Across Constructors

class Initialization {
    int a;
    int b;

    // Instance Initializer Block
    {
        a = 5;
        b = 10;
        System.out.println("Instance Initializer Block executed: a = " + a + ", b = " + b);
    }

    // Constructor 1
    public Initialization() {
        System.out.println("Default constructor called.");
    }

    // Constructor 2
    public Initialization(int b) {
        this.b = b;
        System.out.println("Parameterized constructor called. b = " + b);
    }
}

public class InitializationExample {
    public static void main(String[] args) {
        Initialization obj1 = new Initialization();
        // Output:
        // Instance Initializer Block executed: a = 5, b = 10
        // Default constructor called.

        Initialization obj2 = new Initialization(20);
        // Output:
        // Instance Initializer Block executed: a = 5, b = 10
        // Parameterized constructor called. b = 20
    }
}

Explanation:

The IIB initializes the values of a and b. Both constructors use this shared initialization logic, ensuring that the values are properly set before the constructor logic is executed.

4. Order of Execution: IIB vs Constructor

Instance Initializer Blocks are executed before the constructor but after the instance variables are initialized. The IIB can modify instance variables before the constructor is executed.

Example 3: Execution Order of IIB and Constructor

class ExecutionOrder {
    // Instance variable
    int x = 100;

    // Instance Initializer Block
    {
        System.out.println("IIB executed. Initial value of x = " + x);
        x = 200;  // Modifying the value of x
    }

    // Constructor
    public ExecutionOrder() {
        System.out.println("Constructor executed. Final value of x = " + x);
    }
}

public class ExecutionOrderExample {
    public static void main(String[] args) {
        ExecutionOrder obj = new ExecutionOrder();
        // Output:
        // IIB executed. Initial value of x = 100
        // Constructor executed. Final value of x = 200
    }
}

Explanation:

First, the instance variable x is initialized to 100.
The IIB modifies the value of x to 200.
The constructor is then executed after the IIB, with the final value of x being 200.

5. Multiple Instance Initializer Blocks

You can have multiple Instance Initializer Blocks in a class. They will be executed in the order in which they appear in the class, from top to bottom.

Example 4: Multiple Instance Initializer Blocks

class MultipleIIB {
    int x;
    int y;

    // First Instance Initializer Block
    {
        x = 5;
        System.out.println("First IIB executed: x = " + x);
    }

    // Second Instance Initializer Block
    {
        y = 10;
        System.out.println("Second IIB executed: y = " + y);
    }

    // Constructor
    public MultipleIIB() {
        System.out.println("Constructor executed: x = " + x + ", y = " + y);
    }
}

public class MultipleIIBExample {
    public static void main(String[] args) {
        MultipleIIB obj = new MultipleIIB();
        // Output:
        // First IIB executed: x = 5
        // Second IIB executed: y = 10
        // Constructor executed: x = 5, y = 10
    }
}

Explanation:

The first IIB is executed before the second IIB, which means x is initialized before y.
After both IIBs have executed, the constructor is called to finalize the object creation.

6. Examples and Use Cases

Example 5: Instance Initializer Block for Resource Initialization

Sometimes, you may want to initialize resources or perform setup actions every time an object is created.

class ResourceInitialization {
    // Instance variable
    String resource;

    // Instance Initializer Block
    {
        System.out.println("Initializing resource...");
        resource = "Database Connection";
    }

    // Constructor
    public ResourceInitialization() {
        System.out.println("Constructor: Resource initialized as " + resource);
    }
}

public class ResourceInitializationExample {
    public static void main(String[] args) {
        ResourceInitialization obj = new ResourceInitialization();
        // Output:
        // Initializing resource...
        // Constructor: Resource initialized as Database Connection
    }
}

Explanation:

The IIB simulates resource initialization (such as opening a database connection) every time an object is created.
The constructor then completes the object creation process.

Example 6: Instance Initializer Blocks in Inheritance

When a class extends another class, both the parent and child class can have Instance Initializer Blocks.

class Parent {
    {
        System.out.println("Parent IIB executed.");
    }

    public Parent() {
        System.out.println("Parent constructor executed.");
    }
}

class Child extends Parent {
    {
        System.out.println("Child IIB executed.");
    }

    public Child() {
        System.out.println("Child constructor executed.");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Child obj = new Child();
        // Output:
        // Parent IIB executed.
        // Parent constructor executed.
        // Child IIB executed.
        // Child constructor executed.
    }
}

Explanation:

The IIB in the parent class runs before the IIB in the child class.
The constructor in the parent class is executed before the child class constructor, demonstrating the order of execution.

Summary of Key Concepts for Instance Initializer Blocks

Concept	Description
Instance Initializer Block (IIB)	A block of code that runs before the constructor every time an object is created.
Use for Shared Initialization	IIB can be used to avoid duplicating initialization logic across multiple constructors.
Order of Execution	IIBs are executed before the constructor, but after instance variables are initialized.
Multiple IIBs	If a class contains multiple IIBs, they are executed in the order in which they appear in the class.
IIBs in Inheritance	Both parent and child classes can have IIBs, and the parent's IIB executes before the child's IIB.

Conclusion

In Java, Instance Initializer Blocks (IIBs) are a powerful tool for handling common initialization logic. In this tutorial, we covered:

The basic syntax of Instance Initializer Blocks and how they are executed.
Why and when to use IIBs, especially for shared initialization across constructors.
The order of execution between instance initializer blocks and constructors.
How to use multiple IIBs and their role in inheritance.

October 21, 2024 0 comment

OOP

Java Method Overriding Tutorial with Examples

written by 75ypsaw71

Method Overriding is an important feature of Object-Oriented Programming (OOP) in Java that allows a subclass (child class) to provide its own implementation of a method that is already defined by its superclass (parent class).

Method overriding provides a way to achieve runtime polymorphism in Java.

In this tutorial, we will cover:

What is Method Overriding?
Rules for Method Overriding
Using the @Override Annotation
Difference Between Method Overriding and Overloading
Examples of Method Overriding
Best Practices for Method Overriding
Examples and Use Cases

Let’s dive into each topic with code examples!

1. What is Method Overriding?

Method overriding occurs when a subclass provides its specific implementation of a method that is already defined by its parent class.

The method in the subclass must have the same signature (method name, return type, and parameters) as the method in the parent class.

Key Features:

Runtime Polymorphism: Method overriding enables runtime polymorphism, allowing Java to determine the method to call at runtime.
Same Method Signature: The overridden method in the child class must have the same name, return type, and parameters as the method in the parent class.
Subclass-Specific Implementation: The child class can customize the behavior of the method.

2. Rules for Method Overriding

The method in the child class must have the same name, return type, and parameter list as the method in the parent class.
The access modifier of the overriding method in the child class cannot be more restrictive than the method in the parent class. For example, if the parent method is public, the child method must also be public or more accessible.
The overriding method can throw fewer or no exceptions but not more exceptions than the overridden method in the parent class.
Static methods and constructors cannot be overridden.

3. Using the @Override Annotation

The @Override annotation is used to indicate that a method is intended to override a method in a parent class.

While it is not mandatory, it helps prevent errors by alerting the developer if the method does not correctly override the parent method.

Example: Basic Method Overriding

class Animal {
    // Parent class method
    public void sound() {
        System.out.println("Animal makes a sound.");
    }
}

class Dog extends Animal {
    // Overriding the sound() method in the subclass
    @Override
    public void sound() {
        System.out.println("Dog barks.");
    }
}

public class MethodOverridingExample {
    public static void main(String[] args) {
        Animal animal = new Animal();  // Animal reference, Animal object
        animal.sound();  // Output: Animal makes a sound.

        Animal dog = new Dog();  // Animal reference, Dog object (polymorphism)
        dog.sound();  // Output: Dog barks. (method overridden)
    }
}

Explanation:

The method sound() in the Dog class overrides the sound() method in the Animal class.
The @Override annotation ensures that this method is overriding the method in the parent class.
Polymorphism: The method sound() is called on an Animal reference that holds a Dog object, and the Dog's version of the method is invoked at runtime.

4. Difference Between Method Overriding and Overloading

Method Overriding occurs when a subclass provides a specific implementation of a method that already exists in its superclass.
Method Overloading occurs when two or more methods in the same class share the same name but have different parameter lists.

Example: Overriding vs. Overloading

class Animal {
    public void sound() {
        System.out.println("Animal makes a sound.");
    }
    
    // Overloading: Two methods with the same name but different parameters
    public void sound(String type) {
        System.out.println("Animal makes a sound: " + type);
    }
}

class Dog extends Animal {
    // Overriding: Same method signature as in Animal class
    @Override
    public void sound() {
        System.out.println("Dog barks.");
    }
}

public class OverloadingVsOverriding {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound();  // Output: Dog barks.
        dog.sound("loud bark");  // Output: Animal makes a sound: loud bark (overloaded method)
    }
}

Explanation:

Overloading: The sound() method is overloaded with a different parameter list (sound(String)), which allows different method implementations depending on the arguments passed.
Overriding: The Dog class overrides the sound() method from the Animal class, replacing its behavior.

5. Examples of Method Overriding

Example 1: Overriding a Parent Class Method

class Vehicle {
    public void startEngine() {
        System.out.println("Vehicle engine started.");
    }
}

class Car extends Vehicle {
    @Override
    public void startEngine() {
        System.out.println("Car engine started with ignition key.");
    }
}

public class VehicleExample {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.startEngine();  // Output: Vehicle engine started.

        Vehicle car = new Car();
        car.startEngine();  // Output: Car engine started with ignition key. (overridden method)
    }
}

Example 2: Calling the Parent Class Method from the Overriding Method

You can use the super keyword to call the method from the parent class within the overriding method.

class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        super.eat();  // Call parent class method
        System.out.println("Cat is eating fish.");
    }
}

public class CallParentMethodExample {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
        // Output:
        // Animal is eating.
        // Cat is eating fish.
    }
}

Explanation:

The super.eat() method calls the eat() method from the Animal class, and the Cat class adds its custom behavior by overriding the eat() method.

6. Best Practices for Method Overriding

1. Always Use the @Override Annotation

Using the @Override annotation helps ensure that you are overriding the method from the parent class correctly. It helps avoid subtle bugs caused by method signature mismatches.

2. Follow the Access Modifier Rule

When overriding a method, the access modifier of the overridden method cannot be more restrictive than that of the parent class method. For example, if the parent method is protected, the child class method can be protected or public, but not private.

3. Preserve Method Signatures

Make sure the overriding method has the exact same signature (name, parameters, and return type) as the parent class method. Java will throw a compile-time error if the signatures do not match.

7. Examples and Use Cases

Example 1: Overriding toString() Method

The toString() method is defined in the Object class, and it is common to override it to provide a meaningful string representation of an object.

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Overriding the toString() method
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class ToStringOverrideExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        System.out.println(person.toString());  // Output: Person{name='Alice', age=30}
    }
}

Example 2: Overriding equals() and hashCode() Methods

To correctly compare objects for equality, you need to override both the equals() and hashCode() methods. These methods are defined in the Object class.

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Overriding equals() method
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }

    // Overriding hashCode() method
    @Override
    public int hashCode() {
        return name.hashCode() + age;
    }
}

public class EqualsAndHashCodeExample {
    public static void main(String[] args) {
        Person person1 = new Person("Bob", 25);
        Person person2 = new Person("Bob", 25);


        
        System.out.println(person1.equals(person2));  // Output: true
    }
}

Explanation:

equals() is overridden to check if two Person objects are equal based on their name and age values.
hashCode() is overridden to maintain the contract between equals() and hashCode(), which ensures that equal objects have the same hash code.

Summary of Key Concepts for Method Overriding

Concept	Description
Method Overriding	Allows a subclass to provide its own implementation of a method that is already defined in its superclass.
Runtime Polymorphism	Method overriding enables runtime polymorphism, where the method to be executed is determined at runtime.
@Override Annotation	Used to indicate that a method is intended to override a method in a superclass.
super Keyword	Used to call the parent class's method from within the overriding method.
Access Modifier Rule	The overriding method cannot have a more restrictive access modifier than the method in the parent class.
Overriding vs Overloading	Overriding involves redefining methods with the same signature, while overloading involves different signatures.

Conclusion

In Java, method overriding allows subclasses to customize or replace the behavior of methods defined in their parent classes, enabling runtime polymorphism. In this tutorial, we covered:

The rules for method overriding, including the same method signature and access modifier constraints.
Using the @Override annotation to prevent mistakes in overriding.
Differences between method overriding and method overloading.
Real-world examples, including overriding toString(), equals(), and hashCode().

October 21, 2024 0 comment

File

Java Directory Management Tutorial with Examples

written by 75ypsaw71

Managing directories is an essential task when working with file systems in Java.

The java.nio.file and java.io packages provide classes and methods for creating, deleting, and navigating directories. In this tutorial, we will cover:

Creating Directories
Listing Directory Contents
Checking Directory Existence
Deleting Directories
Navigating Through Directories
Examples and Use Cases

Let’s dive into each topic with examples!

1. Creating Directories

In Java, you can create directories using the Files class from the java.nio.file package or the File class from the java.io package.

Example 1: Creating a Single Directory

Using the Files.createDirectory() method to create a directory:

import java.nio.file.*;

public class CreateDirectoryExample {
    public static void main(String[] args) {
        Path path = Paths.get("exampleDir");
        
        try {
            Files.createDirectory(path);
            System.out.println("Directory created: " + path.toAbsolutePath());
        } catch (FileAlreadyExistsException e) {
            System.out.println("Directory already exists.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Explanation:

Files.createDirectory() creates a single directory. If the directory already exists, a FileAlreadyExistsException is thrown.
The directory will be created in the project's root folder unless an absolute path is specified.

Example 2: Creating Nested Directories

You can use Files.createDirectories() to create a nested directory structure.

import java.nio.file.*;

public class CreateNestedDirectoriesExample {
    public static void main(String[] args) {
        Path nestedPath = Paths.get("exampleDir/nestedDir/subDir");

        try {
            Files.createDirectories(nestedPath);
            System.out.println("Nested directories created: " + nestedPath.toAbsolutePath());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Explanation:

Files.createDirectories() creates all nonexistent parent directories along the specified path.

2. Listing Directory Contents

You can list the contents of a directory using Files.list() or File.listFiles().

Example: Listing Directory Contents Using Files.list()

import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;

public class ListDirectoryContentsExample {
    public static void main(String[] args) {
        Path path = Paths.get("exampleDir");

        try (Stream<Path> stream = Files.list(path)) {
            stream.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation:

Files.list() returns a Stream<Path> containing all files and directories in the specified directory.
The Stream is then processed to print each item in the directory.

Example: Listing Directory Contents Using File.listFiles()

import java.io.File;

public class ListDirectoryUsingFileExample {
    public static void main(String[] args) {
        File directory = new File("exampleDir");

        File[] files = directory.listFiles();
        if (files != null) {
            for (File file : files) {
                System.out.println(file.getName());
            }
        } else {
            System.out.println("Directory is empty or does not exist.");
        }
    }
}

Explanation:

File.listFiles() returns an array of File objects representing the files and directories in the directory.
This method works well for simple use cases but lacks the power of the java.nio.file package's streaming API.

3. Checking Directory Existence

Before performing any operations on a directory, it’s a good practice to check whether it exists.

Example: Checking Directory Existence Using Files.exists()

import java.nio.file.*;

public class DirectoryExistenceCheckExample {
    public static void main(String[] args) {
        Path path = Paths.get("exampleDir");

        if (Files.exists(path) && Files.isDirectory(path)) {
            System.out.println("Directory exists.");
        } else {
            System.out.println("Directory does not exist.");
        }
    }
}

Explanation:

Files.exists() checks whether the path exists.
Files.isDirectory() confirms if the path is a directory.

4. Deleting Directories

Directories can be deleted using Files.delete() or Files.deleteIfExists(). Keep in mind that deleting a non-empty directory requires first deleting all of its contents.

Example 1: Deleting a Single Directory

import java.nio.file.*;

public class DeleteDirectoryExample {
    public static void main(String[] args) {
        Path path = Paths.get("exampleDir");

        try {
            Files.delete(path);
            System.out.println("Directory deleted.");
        } catch (DirectoryNotEmptyException e) {
            System.out.println("Directory is not empty.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Explanation:

Files.delete() deletes the directory if it is empty; otherwise, it throws a DirectoryNotEmptyException.

Example 2: Deleting a Non-Empty Directory (Recursive Deletion)

You can recursively delete all contents of a directory and then the directory itself.

import java.nio.file.*;
import java.io.IOException;

public class DeleteNonEmptyDirectoryExample {
    public static void main(String[] args) {
        Path directory = Paths.get("exampleDir");

        try {
            Files.walk(directory)
                 .sorted((a, b) -> b.compareTo(a))  // Sort in reverse order to delete contents before directory
                 .forEach(path -> {
                     try {
                         Files.delete(path);
                         System.out.println("Deleted: " + path);
                     } catch (IOException e) {
                         e.printStackTrace();
                     }
                 });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation:

Files.walk() is used to recursively walk through all files and directories starting from the given directory.
The sorting ensures that files are deleted before the directory.

5. Navigating Through Directories

You can use Files.walk() to recursively traverse a directory structure.

Example: Navigating Through a Directory Tree

import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;

public class DirectoryTraversalExample {
    public static void main(String[] args) {
        Path path = Paths.get("exampleDir");

        try (Stream<Path> stream = Files.walk(path)) {
            stream.forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation:

Files.walk() returns a Stream<Path> that recursively traverses the directory tree, printing out all files and directories.

6. Examples and Use Cases

Example 1: Copying a Directory

You can recursively copy a directory and its contents.

import java.nio.file.*;
import java.io.IOException;

public class CopyDirectoryExample {
    public static void main(String[] args) {
        Path source = Paths.get("sourceDir");
        Path target = Paths.get("targetDir");

        try {
            Files.walk(source).forEach(sourcePath -> {
                Path targetPath = target.resolve(source.relativize(sourcePath));
                try {
                    Files.copy(sourcePath, targetPath);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            System.out.println("Directory copied successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Explanation:

Files.walk() is used to traverse the source directory.
Files.copy() copies each file and directory to the target location, preserving the directory structure.

Example 2: Moving a Directory

Moving a directory and its contents can be achieved using Files.move().

import java.nio.file.*;

public class MoveDirectoryExample {
    public static void main(String[] args) {
        Path source = Paths.get("sourceDir");
        Path target = Paths.get("targetDir");

        try {
            Files.move(source, target, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("Directory moved successfully.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Explanation:

Files.move() moves the entire directory from the source to the target location.
The StandardCopyOption.REPLACE_EXISTING flag ensures that the target directory is replaced if it already exists.

Summary of Key Methods for Directory Management

Method	Description
Files.createDirectory()	Creates a single directory.
Files.createDirectories()	Creates nested directories along the path.
Files.list()	Lists files and directories in the directory as a stream.
File.listFiles()	Lists files and directories in the directory as an array.
Files.exists()	Checks if a file or directory exists at the specified path.
Files.delete()	Deletes a file or directory (if empty).
Files.walk()	Recursively traverses the directory tree.
Files.copy()	Copies files and directories to a new location.
Files.move()	Moves files and directories to a new location.

Conclusion

Managing directories in Java is made simple and efficient using the java.nio.file and java.io packages. In this tutorial, we covered:

Creating directories with Files.createDirectory() and Files.createDirectories().
Listing directory contents with Files.list() and File.listFiles().
Checking directory existence and ensuring safety before performing operations.
Deleting directories, including recursive deletion for non-empty directories.
Navigating and traversing directories using Files.walk().

October 21, 2024 0 comment

Misc

Java Interrupting a Thread Tutorial with Examples

written by 75ypsaw71

In Java, interrupting a thread is a way of signaling a thread to stop its current execution.

While threads do not stop immediately when interrupted, they can respond to the interruption signal and stop gracefully by checking their interrupt status or handling the InterruptedException.

In this tutorial, we will cover:

What is Thread Interruption in Java?
Using interrupt() to Signal a Thread
Checking the Interrupt Status
Handling InterruptedException
Best Practices for Handling Thread Interruption
Examples and Use Cases

Let’s explore each concept with examples.

1. What is Thread Interruption in Java?

In Java, thread interruption is a mechanism to signal a thread that it should stop its current work. However, thread interruption does not stop the thread immediately.

Instead, it is up to the thread to regularly check its interrupt status or handle an InterruptedException to stop gracefully.

Java threads have a flag called the interrupt flag, which is set when interrupt() is called on the thread.

The thread can check this flag by using methods like Thread.interrupted() or isInterrupted() to decide if it should stop or continue its execution.

2. Using interrupt() to Signal a Thread

The interrupt() method is used to signal a thread that it has been interrupted. This method does not forcefully terminate the thread but sets the interrupt flag to true, which can be checked or handled within the thread.

Example 1: Signaling a Thread Using interrupt()

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running...");

        for (int i = 1; i <= 10; i++) {
            System.out.println("Working on task " + i);

            // Simulate some work with sleep
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted during sleep.");
                return;  // Stop execution when interrupted
            }
        }

        System.out.println("Thread completed.");
    }
}

public class InterruptExample {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();

        try {
            // Give the thread some time to run
            Thread.sleep(3000);  // Main thread sleeps for 3 seconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Interrupt the thread after 3 seconds
        thread.interrupt();
        System.out.println("Thread interrupt signal sent.");
    }
}

Output:

Thread is running...
Working on task 1
Working on task 2
Working on task 3
Thread was interrupted during sleep.
Thread interrupt signal sent.

Explanation:

The interrupt() method sends a signal to the thread. The thread does not stop immediately but can check the interrupt status and handle it.
In the example, the thread is interrupted during its sleep(), and the InterruptedException is caught. The thread then terminates gracefully.

3. Checking the Interrupt Status

You can check a thread's interrupt status using either Thread.interrupted() or isInterrupted().

Thread.interrupted(): Checks if the current thread has been interrupted and clears the interrupt flag after checking.
isInterrupted(): Checks if the thread has been interrupted without clearing the flag.

Example 2: Checking the Interrupt Status Using isInterrupted()

class MyTask implements Runnable {
    public void run() {
        System.out.println("Thread is running...");

        for (int i = 1; i <= 5; i++) {
            System.out.println("Task " + i);

            // Check if the thread has been interrupted
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("Thread was interrupted. Exiting...");
                break;
            }

            // Simulate some work with sleep
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted during sleep.");
                return;
            }
        }

        System.out.println("Thread completed.");
    }
}

public class InterruptCheckExample {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyTask());
        thread.start();

        try {
            Thread.sleep(2000);  // Main thread sleeps for 2 seconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Interrupt the thread after 2 seconds
        thread.interrupt();
    }
}

Output:

Thread is running...
Task 1
Task 2
Thread was interrupted. Exiting...
Thread was interrupted during sleep.

Explanation:

The isInterrupted() method is used to check if the thread has been interrupted.
When the interrupt flag is set, the thread checks this status and exits the loop early.

4. Handling InterruptedException

When a thread is interrupted during a blocking operation like Thread.sleep(), wait(), or join(), it throws an InterruptedException. This exception must be handled inside the thread to ensure the thread responds to interruptions.

Example 3: Handling InterruptedException in Thread

class BlockingTask implements Runnable {
    public void run() {
        System.out.println("Thread is performing a blocking operation...");

        try {
            // Simulating a long operation with sleep
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            System.out.println("Thread was interrupted during a blocking operation.");
            return;  // Stop execution when interrupted
        }

        System.out.println("Thread finished blocking operation.");
    }
}

public class InterruptBlockingExample {
    public static void main(String[] args) {
        Thread thread = new Thread(new BlockingTask());
        thread.start();

        try {
            Thread.sleep(2000);  // Main thread sleeps for 2 seconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Interrupt the thread while it's performing a blocking operation
        thread.interrupt();
        System.out.println("Interrupt signal sent to the thread.");
    }
}

Output:

Thread is performing a blocking operation...
Interrupt signal sent to the thread.
Thread was interrupted during a blocking operation.

Explanation:

The thread is interrupted while it is sleeping (Thread.sleep()), and the InterruptedException is caught. The thread then stops its execution.

5. Best Practices for Handling Thread Interruption

Check for Interruption Regularly: In long-running tasks or loops, make sure to check the interrupt status regularly using isInterrupted() or Thread.interrupted() to handle interruptions gracefully.
```
if (Thread.currentThread().isInterrupted()) {
    // Handle the interruption, e.g., clean up resources or stop the task
    break;
}
```

Respond to InterruptedException: When a thread is interrupted during a blocking operation, such as sleep() or wait(), it should handle the InterruptedException by cleaning up and stopping the task.

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // Handle the exception and stop the thread
    Thread.currentThread().interrupt();  // Preserve the interrupt status
    return;
}

Preserve the Interrupt Status: If you catch an InterruptedException, it's a good practice to call Thread.currentThread().interrupt() to restore the interrupt flag if you intend to propagate the interruption.

6. Examples and Use Cases

Example 4: Gracefully Stopping a Long-Running Task

Let’s say you have a long-running task that should stop when an interrupt signal is received. You can check for interruptions in each iteration of the task.

class LongRunningTask implements Runnable {
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("Processing task " + i);

            // Check for interrupt signal
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("Thread was interrupted. Stopping task...");
                break;
            }

            // Simulate a time-consuming operation
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted during sleep. Exiting...");
                return;
            }
        }

        System.out.println("Task completed.");
    }
}

public class LongRunningTaskExample {
    public static void main(String[] args) {
        Thread thread = new Thread(new LongRunningTask());
        thread.start();

        try {
            Thread.sleep(4000);  // Main thread sleeps for 4 seconds
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Interrupt the thread
        thread.interrupt();
    }
}

Output:

Processing task 1
Processing task 2
Processing task 3
Processing task 4
Thread was interrupted. Stopping task...

Explanation:

The thread processes tasks in a loop, checking the interrupt flag during each iteration.
When the interrupt signal is sent, the thread stops gracefully before completing all tasks.

Summary of Key Concepts for Thread Interruption

Concept	Description
interrupt()	Signals a thread that it has been interrupted by setting the interrupt flag to true.
isInterrupted()	Checks if the current thread has been interrupted without clearing the interrupt flag.
Thread.interrupted()	Checks if the current thread has been interrupted and clears the interrupt flag.
InterruptedException	Thrown when a thread is interrupted during a blocking operation (like sleep(), wait(), or join()).
Best Practice	Regularly check for interruptions and handle InterruptedException properly by cleaning up and stopping the task.
Restoring Interrupt Status	If you catch InterruptedException, call Thread.currentThread().interrupt() to restore the interrupt status.

Conclusion

In this tutorial, we explored how to interrupt threads in Java using the interrupt() method and handle thread interruptions gracefully.

We covered:

The use of the interrupt() method to signal threads.
How to check the interrupt status using isInterrupted() and Thread.interrupted().
Handling InterruptedException when a thread is performing a blocking operation.
Best practices for handling thread interruptions in long-running tasks.

October 21, 2024 0 comment

Misc

Reentrant Monitors in Java tutorial with code examples

written by 75ypsaw71

In Java, monitors (also known as intrinsic locks) are used to control access to critical sections of code that should not be executed by multiple threads simultaneously. These monitors ensure mutual exclusion and thread synchronization.

A Reentrant Monitor allows a thread that has already acquired a lock to re-enter the same synchronized block or method it previously entered.

This is essential when a thread needs to acquire the same lock multiple times, such as when it calls methods within synchronized methods or re-enters synchronized blocks.

In Java, the concept of reentrant monitors is built into the synchronized keyword. Additionally, Java provides a more flexible class, ReentrantLock, from the java.util.concurrent.locks package, which allows explicit lock acquisition and release with advanced features like fairness policies and interruptibility.

Table of Contents

1. Using synchronized as a Reentrant Monitor

In Java, every object has an intrinsic lock, and when a thread enters a synchronized method or block, it acquires the lock. If the same thread attempts to enter another synchronized block that requires the same lock, it can re-enter (hence “reentrant”) without deadlocking.

Example 1: Reentrant Synchronization with synchronized

class ReentrantExample {
    public synchronized void methodA() {
        System.out.println("Inside method A");
        methodB(); // Re-entrant lock: This thread will not block here.
    }

    public synchronized void methodB() {
        System.out.println("Inside method B");
    }
}

public class ReentrantMonitorExample1 {
    public static void main(String[] args) {
        ReentrantExample example = new ReentrantExample();
        example.methodA();
    }
}

Output:

Inside method A
Inside method B

Explanation:

The method methodA() is synchronized, meaning it requires the current thread to acquire the object’s intrinsic lock.
When methodB() is called within methodA(), the thread can re-enter the lock it already holds, demonstrating reentrant behavior.

2. ReentrantLock: Advanced Reentrant Monitor

The ReentrantLock class is part of the java.util.concurrent.locks package and provides additional features compared to the synchronized keyword:

You can explicitly lock and unlock.
It supports interruptible and timed lock acquisition.
It allows fairness policies (to ensure locks are granted in order of request).

Example 2: Using ReentrantLock

import java.util.concurrent.locks.ReentrantLock;

class ReentrantLockExample {
    private ReentrantLock lock = new ReentrantLock();

    public void methodA() {
        lock.lock(); // Acquire the lock
        try {
            System.out.println("Inside method A");
            methodB(); // Re-entrant lock: This thread can acquire the lock again.
        } finally {
            lock.unlock(); // Release the lock
        }
    }

    public void methodB() {
        lock.lock(); // Acquire the lock
        try {
            System.out.println("Inside method B");
        } finally {
            lock.unlock(); // Release the lock
        }
    }
}

public class ReentrantMonitorExample2 {
    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        example.methodA();
    }
}

Output:

Inside method A
Inside method B

Explanation:

The ReentrantLock allows the same thread to re-enter the lock when it calls methodB() from within methodA().
The lock.lock() method acquires the lock, and lock.unlock() releases it.
Reentrant locks ensure that a thread that has already acquired the lock can reacquire it.

3. Preventing Deadlock with Reentrant Monitors

Without reentrant locks, recursive calls to synchronized methods could lead to deadlock.

Here’s an example where the absence of reentrancy would cause deadlock, but reentrant monitors allow the thread to proceed safely.

Example 3: Recursive Reentrant Lock

class ReentrantRecursiveExample {
    public synchronized void recursiveMethod(int count) {
        if (count > 0) {
            System.out.println("Recursive count: " + count);
            recursiveMethod(count - 1); // Re-enter the same lock
        }
    }
}

public class ReentrantMonitorExample3 {
    public static void main(String[] args) {
        ReentrantRecursiveExample example = new ReentrantRecursiveExample();
        example.recursiveMethod(5); // Recursively call the method with a countdown
    }
}

Output:

Recursive count: 5
Recursive count: 4
Recursive count: 3
Recursive count: 2
Recursive count: 1

Explanation:

The recursiveMethod() calls itself recursively, and since it's synchronized, the current thread re-enters the same lock multiple times.
Without a reentrant monitor, this would result in a deadlock. However, with reentrancy, the same thread can reacquire the lock as needed.

4. Fairness with ReentrantLock

The ReentrantLock class supports a fairness policy. When fairness is enabled, locks are granted in the order they were requested, preventing “starvation” of threads.

Example 4: Using Fair ReentrantLock

import java.util.concurrent.locks.ReentrantLock;

class FairReentrantLockExample {
    private ReentrantLock lock = new ReentrantLock(true); // Fair lock

    public void accessResource(String threadName) {
        lock.lock(); // Acquire the lock
        try {
            System.out.println(threadName + " has acquired the lock.");
            Thread.sleep(1000); // Simulate some work
        } catch (InterruptedException e) {
            System.out.println(e);
        } finally {
            System.out.println(threadName + " is releasing the lock.");
            lock.unlock(); // Release the lock
        }
    }
}

public class ReentrantMonitorExample4 {
    public static void main(String[] args) {
        FairReentrantLockExample example = new FairReentrantLockExample();
        Runnable task = () -> example.accessResource(Thread.currentThread().getName());

        // Start multiple threads
        Thread t1 = new Thread(task, "Thread 1");
        Thread t2 = new Thread(task, "Thread 2");
        Thread t3 = new Thread(task, "Thread 3");

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

Output:

Thread 1 has acquired the lock.
Thread 1 is releasing the lock.
Thread 2 has acquired the lock.
Thread 2 is releasing the lock.
Thread 3 has acquired the lock.
Thread 3 is releasing the lock.

Explanation:

The ReentrantLock is created with the fairness flag set to true, which ensures that threads acquire the lock in the order they requested it.
This prevents thread starvation, where one thread might monopolize the lock while other threads are waiting.

5. Try Locking with ReentrantLock

The ReentrantLock class provides a tryLock() method, which allows a thread to attempt to acquire the lock without blocking indefinitely. This is useful when you don't want a thread to wait forever for a lock.

Example 5: Using tryLock()

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

class TryLockExample {
    private ReentrantLock lock = new ReentrantLock();

    public void accessResource(String threadName) {
        try {
            if (lock.tryLock(500, TimeUnit.MILLISECONDS)) { // Try to acquire the lock for 500ms
                try {
                    System.out.println(threadName + " has acquired the lock.");
                    Thread.sleep(1000); // Simulate some work
                } finally {
                    System.out.println(threadName + " is releasing the lock.");
                    lock.unlock(); // Release the lock
                }
            } else {
                System.out.println(threadName + " could not acquire the lock.");
            }
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }
}

public class ReentrantMonitorExample5 {
    public static void main(String[] args) {
        TryLockExample example = new TryLockExample();
        Runnable task = () -> example.accessResource(Thread.currentThread().getName());

        // Start multiple threads
        Thread t1 = new Thread(task, "Thread 1");
        Thread t2 = new Thread(task, "Thread 2");

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

Output:

Thread 1 has acquired the lock.
Thread 2 could not acquire the lock.
Thread 1 is releasing the lock.

Explanation:

tryLock() allows the thread to attempt to acquire the lock without blocking indefinitely.
If the lock is not available within 500 milliseconds, the thread proceeds without acquiring the lock.

6. Using ReentrantLock with Conditions

The ReentrantLock class supports conditions via the Condition object. This allows threads to wait for specific conditions before proceeding, similar to Object.wait() and Object.notify().

Example 6: Using Condition with ReentrantLock

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

class ConditionExample {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean isConditionMet = false;

    public void waitForCondition() throws InterruptedException {
        lock.lock();
        try {
            while (!isConditionMet) {
                System.out.println("Waiting for the condition to be met...");
                condition.await(); // Wait for the condition
            }
            System.out.println("Condition met, proceeding...");
        } finally {
            lock.unlock();
        }
    }

    public void signalCondition() {
        lock.lock();
        try {
            isConditionMet = true;
            condition.signalAll(); // Signal all waiting threads
        } finally {
            lock.unlock();
        }
    }
}

public class ReentrantMonitorExample6 {
    public static void main(String[] args) {
        ConditionExample example = new ConditionExample();

        // Thread waiting for the condition
        Thread waiter = new Thread(() -> {
            try {
                example.waitForCondition();
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        });

        // Thread signaling the condition
        Thread signaler = new Thread(example::signalCondition);

        waiter.start();

        try {
            Thread.sleep(2000); // Simulate some delay before signaling
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        signaler.start();
    }
}

Output:

Waiting for the condition to be met...
Condition met, proceeding...

Explanation:

The Condition object is used to make the waitForCondition() thread wait until a specific condition is met.
The signaler thread calls signalCondition(), which changes the condition and wakes up the waiting thread.

Conclusion

In Java, reentrant monitors are an essential mechanism for controlling access to shared resources across multiple threads.

The built-in synchronized keyword provides basic reentrant locking functionality, while the ReentrantLock class from the java.util.concurrent.locks package offers more flexibility and features such as fairness policies, timed locking, and explicit lock handling.

Key points:

Reentrancy: A thread holding a lock can acquire it again (useful for recursive and nested lock acquisitions).
synchronized keyword: Automatically provides reentrancy, though it's implicit and has no extra features.
ReentrantLock: Provides explicit locking with features like fairness, timed locks, and conditions.
tryLock(): Useful for attempting to acquire a lock without blocking indefinitely.
Condition: Allows fine-grained control over thread communication and synchronization.

October 15, 2024 0 comment

Misc

Joining Threads in Java tutorial with code examples

written by 75ypsaw71

In Java, joining threads allows one thread to wait for the completion of another thread before proceeding.

The Thread.join() method is crucial for ensuring that certain operations occur after other threads have finished executing.

This is especially useful in scenarios where you need to synchronize thread execution or coordinate the result of multiple threads.

Table of Contents

The join() method blocks the calling thread until the thread on which join() was called terminates. There are three variations of the join() method:

join() – Waits indefinitely until the thread completes.
join(long millis) – Waits for the specified time (in milliseconds) for the thread to finish.
join(long millis, int nanos) – Waits for the specified time (in milliseconds and nanoseconds) for the thread to finish.

1. Basic Example of Thread.join()

In this first example, we will demonstrate how the main thread can wait for a secondary thread to complete using the join() method.

Example 1: Basic Join

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(500); // Sleep for 500 milliseconds
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class JoinExample1 {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();

        try {
            thread.join(); // Main thread waits for thread to finish
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Main thread has finished after child thread.");
    }
}

Output:

Thread: 1
Thread: 2
Thread: 3
Thread: 4
Thread: 5

Main thread has finished after child thread.

Explanation:

The join() method ensures that the main thread waits for the MyThread to complete before printing “Main thread has finished after child thread.”.
The main thread will only continue once the child thread has finished its execution.

2. Using join(long millis) to Specify Wait Time

The join(long millis) method allows the main thread to wait for a specific amount of time before it resumes execution.

If the specified time elapses before the thread finishes, the main thread continues without waiting for the child thread to finish.

Example 2: Using join(long millis)

class MyThreadWithDelay extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(1000); // Sleep for 1 second
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class JoinExample2 {
    public static void main(String[] args) {
        MyThreadWithDelay thread = new MyThreadWithDelay();
        thread.start();

        try {
            thread.join(2500); // Main thread waits for 2.5 seconds
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Main thread proceeds after 2.5 seconds.");
    }
}

Output:

Thread: 1
Thread: 2
Main thread proceeds after 2.5 seconds.
Thread: 3
Thread: 4
Thread: 5

Explanation:

The join(2500) makes the main thread wait for 2.5 seconds. After this time, the main thread resumes execution, regardless of whether the child thread has finished.
In this case, the child thread continues running, but the main thread proceeds after the specified waiting time.

3. Using join(long millis, int nanos) for Higher Precision

The join(long millis, int nanos) method allows even finer control over the waiting time, providing additional precision using nanoseconds.

Example 3: Using join(long millis, int nanos)

class MyThreadWithNanoDelay extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(1000); // Sleep for 1 second
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class JoinExample3 {
    public static void main(String[] args) {
        MyThreadWithNanoDelay thread = new MyThreadWithNanoDelay();
        thread.start();

        try {
            thread.join(1000, 500000); // Main thread waits for 1.5 seconds (1 second and 500,000 nanoseconds)
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Main thread proceeds after 1.5 seconds.");
    }
}

Output:

Thread: 1
Thread: 2
Main thread proceeds after 1.5 seconds.
Thread: 3
Thread: 4
Thread: 5

Explanation:

The join(1000, 500000) makes the main thread wait for approximately 1.5 seconds.
After the waiting time elapses, the main thread proceeds with execution, even if the child thread has not yet finished.

4. Joining Multiple Threads

You can also use the join() method to synchronize multiple threads. In this case, the main thread can wait for several threads to finish before proceeding.

Example 4: Joining Multiple Threads

class WorkerThread extends Thread {
    private String name;

    public WorkerThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println(name + ": " + i);
            try {
                Thread.sleep(500); // Sleep for 500 milliseconds
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class JoinExample4 {
    public static void main(String[] args) {
        WorkerThread thread1 = new WorkerThread("Thread 1");
        WorkerThread thread2 = new WorkerThread("Thread 2");
        WorkerThread thread3 = new WorkerThread("Thread 3");

        thread1.start();
        thread2.start();
        thread3.start();

        try {
            thread1.join(); // Wait for thread1 to finish
            thread2.join(); // Wait for thread2 to finish
            thread3.join(); // Wait for thread3 to finish
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Main thread proceeds after all threads are finished.");
    }
}

Output:

Thread 1: 1
Thread 2: 1
Thread 3: 1
Thread 1: 2
Thread 2: 2
Thread 3: 2
Thread 1: 3
Thread 2: 3
Thread 3: 3
Main thread proceeds after all threads are finished.

Explanation:

The main thread waits for thread1, thread2, and thread3 to finish execution before proceeding.
By calling join() on each thread, the main thread ensures that all worker threads complete before it moves on.

5. Handling Interrupted Threads with join()

When using join(), a thread may be interrupted. It’s important to handle this scenario using the InterruptedException.

Example 5: Handling Interrupted Threads

class InterruptibleThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(500); // Sleep for 500 milliseconds
            } catch (InterruptedException e) {
                System.out.println("Thread was interrupted!");
                return;
            }
        }
    }
}

public class JoinExample5 {
    public static void main(String[] args) {
        InterruptibleThread thread = new InterruptibleThread();
        thread.start();

        try {
            thread.join();
        } catch (InterruptedException e) {
            System.out.println("Main thread was interrupted!");
        }

        System.out.println("Main thread proceeds after thread completion or interruption.");
    }
}

Output:

Thread: 1
Thread: 2
Thread: 3
Main thread proceeds after thread completion or interruption.

Explanation:

If the thread gets interrupted while waiting, the InterruptedException is thrown.
In this case, the main thread catches the exception and handles the interruption gracefully.

6. Using join() in a Thread Pool

In real-world applications, we often use thread pools to manage multiple threads. Even within a thread pool, you can use join() to wait for specific threads to complete their tasks.

Example 6: Using join() with a Thread Pool

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class ThreadPoolTask extends Thread {
    private String taskName;

    public ThreadPoolTask(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        System.out.println(taskName + " is running.");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            System.out.println(taskName + " was interrupted.");
        }
        System.out.println(taskName + " has finished.");
    }
}

public class JoinExample6 {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        
        ThreadPoolTask task1 = new ThreadPoolTask("Task 1");
        ThreadPoolTask task2 = new ThreadPoolTask("Task 2");
        ThreadPoolTask task3 = new ThreadPoolTask("Task 3");

        executor.execute(task1);
        executor.execute(task2);
        executor.execute(task3);

        executor.shutdown(); // Gracefully shut down the executor

        try {
            task1.join();
            task2.join();
            task3.join();
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Main thread proceeds after all tasks are completed.");
    }
}

Output:

Task 1 is running.
Task 2 is running.
Task 3 is running.
Task 1 has finished.
Task 2 has finished.
Task 3 has finished.
Main thread proceeds after all tasks are completed.

Explanation:

In this example, the ExecutorService manages multiple threads.
After submitting the tasks to the thread pool, the join() method ensures that the main thread waits for the tasks to finish.

Conclusion

The join() method in Java is a powerful tool for controlling the execution order of threads.

It allows one thread to wait for the completion of another before proceeding, making it useful for scenarios where you need to synchronize threads or ensure that certain tasks complete before moving forward.

Key points:

Use join() to make one thread wait for another.
The join(long millis) and join(long millis, int nanos) methods allow you to specify how long to wait before continuing.
Handling InterruptedException is important when dealing with threads.
You can join multiple threads or use join() in thread pools to coordinate task completion.

October 15, 2024 0 comment

Misc

Starting a Thread in Java tutorial with code examples

written by 75ypsaw71

In Java, threads are a fundamental part of concurrency and multi-threading. A thread is a lightweight process that allows a program to perform multiple tasks simultaneously.

Java provides several ways to create and start a thread, which is useful for making applications more responsive and capable of handling multiple operations concurrently.

Table of Contents

There are two main ways to start a thread in Java:

Extending the Thread class.

Implementing the Runnable interface.
Both approaches allow you to run code concurrently, but they differ in how they are implemented and in their flexibility.

1. Starting a Thread by Extending the Thread Class

One way to create a thread in Java is by extending the Thread class and overriding its run() method. The run() method contains the code that will be executed by the thread.

Example 1: Extending the Thread Class

class MyThread extends Thread {
    @Override
    public void run() {
        // Code that will be executed by the thread
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread: " + i);
            try {
                Thread.sleep(500); // Sleep for 500 milliseconds
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class ThreadExample1 {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // Start the thread
        
        // Main thread continues
        for (int i = 1; i <= 5; i++) {
            System.out.println("Main: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

Output (might vary due to thread scheduling):

Thread: 1
Main: 1
Thread: 2
Main: 2
Thread: 3
Main: 3
Thread: 4
Main: 4
Thread: 5
Main: 5

Explanation:

In this example, the MyThread class extends Thread and overrides the run() method.
The start() method is called to initiate the thread, which internally calls the run() method.
Both the main thread and the newly created thread run concurrently.

2. Starting a Thread by Implementing the Runnable Interface

Another way to start a thread is by implementing the Runnable interface. This approach is more flexible because your class can extend another class, unlike the previous method where you are restricted to extending Thread.

Example 2: Implementing the Runnable Interface

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Runnable: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class ThreadExample2 {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start(); // Start the thread
        
        // Main thread continues
        for (int i = 1; i <= 5; i++) {
            System.out.println("Main: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

Output (might vary):

Runnable: 1
Main: 1
Runnable: 2
Main: 2
Runnable: 3
Main: 3
Runnable: 4
Main: 4
Runnable: 5
Main: 5

Explanation:

The MyRunnable class implements the Runnable interface and provides the implementation of the run() method.
A Thread object is created and passed the runnable object as an argument to its constructor.
The start() method starts the thread, which invokes the run() method of MyRunnable.

3. Using Lambda Expressions with Threads

In Java 8 and later, you can use lambda expressions to create a thread in a more concise way when using the Runnable interface. This is particularly useful for reducing boilerplate code.

Example 3: Using Lambda Expression

public class ThreadExample3 {
    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Lambda: " + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    System.out.println(e);
                }
            }
        };
        
        Thread thread = new Thread(task);
        thread.start(); // Start the thread
        
        // Main thread continues
        for (int i = 1; i <= 5; i++) {
            System.out.println("Main: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

Output:

Lambda: 1
Main: 1
Lambda: 2
Main: 2
Lambda: 3
Main: 3
Lambda: 4
Main: 4
Lambda: 5
Main: 5

Explanation:

In this example, the Runnable task is defined using a lambda expression, making the code more concise.
This approach is a modern and convenient way to create threads in Java, especially for short and simple tasks.

4. Using the Thread.join() Method

The join() method allows one thread to wait for the completion of another. This can be useful when you want the main thread to wait until another thread finishes its work.

Example 4: Using Thread.join()

class MyTask implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Task: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class ThreadExample4 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyTask());
        thread.start(); // Start the thread

        try {
            thread.join(); // Wait for the thread to finish
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        // Now the main thread will execute
        System.out.println("Main thread completed after task.");
    }
}

Output:

Task: 1
Task: 2
Task: 3
Task: 4
Task: 5
Main thread completed after task.

Explanation:

The thread.join() method makes the main thread wait for the thread to complete its execution before proceeding.
After the thread finishes, the main thread continues its execution.

5. Thread Priorities

Threads in Java can be assigned priorities. Java provides three priority levels:

Thread.MIN_PRIORITY (1)
Thread.NORM_PRIORITY (5) (default)
Thread.MAX_PRIORITY (10)
You can set a thread's priority using the setPriority() method, but keep in mind that thread priorities are only hints to the thread scheduler and may not be strictly followed by the JVM on all platforms.

Example 5: Setting Thread Priorities

class PriorityTask implements Runnable {
    private String name;

    public PriorityTask(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println(name + ": " + i);
        }
    }
}

public class ThreadExample5 {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new PriorityTask("Low Priority"));
        Thread thread2 = new Thread(new PriorityTask("High Priority"));

        thread1.setPriority(Thread.MIN_PRIORITY); // Priority 1
        thread2.setPriority(Thread.MAX_PRIORITY); // Priority 10

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

Output:

High Priority: 1
High Priority: 2
High Priority: 3
Low Priority: 1
Low Priority: 2
Low Priority: 3

Explanation:

The thread with higher priority (thread2) is more likely to execute first, but thread scheduling is still dependent on the JVM and the operating system.
Setting priorities does not guarantee the order of execution.

6. Daemon Threads

A daemon thread is a low-priority thread that runs in the background to perform tasks like garbage collection. These threads do not prevent the JVM from exiting when all user threads (non-daemon threads) finish their execution.

Example 6: Daemon Thread

class DaemonTask implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("Daemon thread running...");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println(e);
            }
        }
    }
}

public class ThreadExample6 {
    public static void main(String[] args) {
        Thread daemonThread = new Thread(new DaemonTask());
        daemonThread.setDaemon(true); // Set this thread as daemon
        daemonThread.start();

        try {
            Thread.sleep(2000); // Main thread sleeps for 2 seconds
        } catch (InterruptedException e) {
            System.out.println(e);
        }

        System.out.println("Main thread finished.");
    }
}

Output:

Daemon thread running...
Daemon thread running...
Daemon thread running...
Daemon thread running...
Main thread finished.

Explanation:

The daemon thread keeps running, but as soon as the main thread (the non-daemon thread) finishes, the program terminates, and the daemon thread is also stopped automatically.
Daemon threads are typically used for background tasks like garbage collection.

Conclusion

Java provides a variety of ways to create and manage threads, from extending the Thread class to implementing the Runnable interface.

You can control thread behavior using features like join(), priorities, and daemon threads. Understanding how to use threads effectively is crucial for building efficient, concurrent applications.

Key takeaways:

Extending Thread or implementing Runnable are two primary ways to start threads.
Use lambda expressions for concise code in modern Java.
Use join() to make one thread wait for another to finish.
Control thread execution order with priorities (though it's only a hint).
Use daemon threads for background tasks that should not prevent the JVM from exiting.

October 15, 2024 0 comment

Newer Posts

Older Posts