Category:

Advanced

Java Lambda Expressions

written by 75ypsaw71

Java Lambda Expressions, introduced in Java 8, provide a clear and concise way to represent one method interface using an expression.

They are particularly useful for functional interfaces, which are interfaces with a single abstract method.

Lambda expressions help simplify code by eliminating the need for anonymous classes, making code more readable and easier to maintain.

Syntax of Lambda Expressions

The syntax of a lambda expression is:

(parameters) -> expression
(parameters) -> { statements; }

(parameters): The input parameters for the method.
->: The arrow token separates parameters from the expression or block of code.
expression or { statements; }: The body of the lambda expression, which can either be a single expression or a block of statements.

Key Points about Lambda Expressions

Functional Interface Requirement: Lambda expressions can only be used with functional interfaces.
Type Inference: The types of parameters can be inferred by the compiler.
Conciseness: Lambdas simplify code by reducing boilerplate syntax.

Example 1: Basic Lambda Expression with Runnable

The Runnable interface is a functional interface with a single run() method, which is ideal for a lambda expression.

Example

public class LambdaRunnableExample {
    public static void main(String[] args) {
        // Using lambda expression for Runnable
        Runnable task = () -> System.out.println("Task is running");
        
        // Start a thread with the lambda expression
        Thread thread = new Thread(task);
        thread.start();
    }
}

Explanation

We create a Runnable using a lambda expression instead of an anonymous inner class.
Runnable task = () -> System.out.println(“Task is running”); represents the run() method of Runnable.

Output

Task is running

Example 2: Lambda Expression with Parameters

This example uses a lambda expression with parameters in the Comparator interface to compare two strings by their lengths.

Example

import java.util.Arrays;
import java.util.Comparator;

public class LambdaComparatorExample {
    public static void main(String[] args) {
        String[] names = { "John", "Alice", "Bob", "Charlie" };
        
        // Using lambda expression to sort by string length
        Arrays.sort(names, (s1, s2) -> Integer.compare(s1.length(), s2.length()));
        
        // Display sorted array
        System.out.println(Arrays.toString(names));
    }
}

Explanation

(s1, s2) -> Integer.compare(s1.length(), s2.length()) is a lambda expression that implements the compare method of Comparator<String>.
This lambda expression sorts strings by their lengths.

Output

[Bob, John, Alice, Charlie]

Example 3: Using Lambda with Custom Functional Interface

You can define your own functional interface to use with lambda expressions.

Example

@FunctionalInterface
interface Greeting {
    void sayHello(String name);
}

public class LambdaCustomInterfaceExample {
    public static void main(String[] args) {
        // Lambda expression for Greeting interface
        Greeting greeting = name -> System.out.println("Hello, " + name + "!");
        
        // Use the lambda expression
        greeting.sayHello("Alice");
        greeting.sayHello("Bob");
    }
}

Explanation

Greeting is a custom functional interface with a single method sayHello.
name -> System.out.println(“Hello, ” + name + “!”) is a lambda that implements sayHello to greet a user by name.

Output

Hello, Alice!
Hello, Bob!

Example 4: Lambda Expression with Block of Statements

If the lambda body has multiple statements, enclose them in curly braces { }.

Example

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

public class LambdaBlockExample {
    public static void main(String[] args) {
        // Lambda expression with multiple statements in the body
        MathOperation addition = (a, b) -> {
            System.out.println("Adding " + a + " and " + b);
            return a + b;
        };
        
        int result = addition.operate(5, 3);
        System.out.println("Result: " + result);
    }
}

Explanation

(a, b) -> { System.out.println(“Adding ” + a + ” and ” + b); return a + b; } has a block of statements within the lambda.
The lambda prints each operand before performing the addition.

Output

Adding 5 and 3
Result: 8

Example 5: Lambda Expressions with Predicate Functional Interface

The Predicate<T> interface is a generic functional interface that accepts a single argument and returns a boolean result. It’s commonly used in filter operations.

Example

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class LambdaPredicateExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // Predicate to check if a string starts with "A"
        Predicate<String> startsWithA = s -> s.startsWith("A");

        // Filter and print names starting with "A"
        names.stream()
             .filter(startsWithA)
             .forEach(System.out::println);
    }
}

Explanation

Predicate<String> startsWithA = s -> s.startsWith(“A”) checks if a string starts with “A”.
filter(startsWithA) filters the stream to include only names that start with “A”.

Output

Alice

Example 6: Using Lambda with Function Interface

The Function<T, R> interface is a functional interface that accepts one argument of type T and returns a result of type R.

Example

import java.util.function.Function;

public class LambdaFunctionExample {
    public static void main(String[] args) {
        // Function to calculate the square of an integer
        Function<Integer, Integer> square = x -> x * x;

        // Use the function
        System.out.println("Square of 5: " + square.apply(5));
        System.out.println("Square of 10: " + square.apply(10));
    }
}

Explanation

Function<Integer, Integer> square = x -> x * x; is a lambda that calculates the square of a number.
apply is called with the argument to calculate and print the square.

Output

Square of 5: 25
Square of 10: 100

Example 7: Method References with Lambda Expressions

Java provides method references as a shorthand notation for lambdas that call a single method. They are often used to refer to existing methods or constructors.

Example

import java.util.Arrays;
import java.util.List;

public class LambdaMethodReferenceExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // Method reference instead of lambda expression
        names.forEach(System.out::println);
    }
}

Explanation

System.out::println is a method reference that refers to System.out.println(String).
This replaces a lambda that would have called println on each name in the list.

Output

Alice
Bob
Charlie

Example 8: Lambda Expression with BiFunction

The BiFunction<T, U, R> functional interface takes two arguments of types T and U, and returns a result of type R.

Example

import java.util.function.BiFunction;

public class LambdaBiFunctionExample {
    public static void main(String[] args) {
        // BiFunction to concatenate two strings with a space
        BiFunction<String, String, String> concatenate = (s1, s2) -> s1 + " " + s2;

        // Use the BiFunction
        String result = concatenate.apply("Hello", "World");
        System.out.println("Concatenated String: " + result);
    }
}

Explanation

(s1, s2) -> s1 + ” ” + s2 is a lambda that concatenates two strings with a space in between.
The apply method is called to concatenate “Hello” and “World”.

Output

Concatenated String: Hello World

Summary

Java lambda expressions simplify working with functional interfaces, making code more concise and readable.

Key points include:

Syntax: (parameters) -> expression or (parameters) -> { statements }.
Functional Interfaces: Lambdas work with interfaces that have a single abstract method.
Common Functional Interfaces:
- Runnable, Comparator, Predicate, Function, BiFunction, etc.
Method References: Provide a shorthand for lambdas that only call one method.

Lambda expressions are a core feature for functional programming in Java, making it easier to work with collections, streams, and functional interfaces.

November 4, 2024 0 comment

Advanced

Java Base64 encoding and decoding

written by 75ypsaw71

In Java, Base64 encoding and decoding are commonly used for encoding binary data as text.

This is especially useful in contexts where data needs to be safely transmitted over networks, stored in text files, or embedded in XML or JSON.

Java provides built-in support for Base64 encoding and decoding through the java.util.Base64 class introduced in Java 8.

Base64 Encoding and Decoding Basics

The Base64 class provides three built-in encoders and decoders:

Basic: Standard Base64 encoding without any line separators.
URL and Filename Safe: Base64 encoding modified to be URL and filename safe by replacing certain characters.
MIME: Base64 encoding suitable for MIME (Multipurpose Internet Mail Extensions) with line breaks.

1. Basic Base64 Encoding and Decoding

The Base64.getEncoder() and Base64.getDecoder() methods provide basic encoding and decoding.

Example: Encoding and Decoding a Simple String

import java.util.Base64;

public class Base64BasicExample {
    public static void main(String[] args) {
        String originalString = "Hello, World!";
        
        // Encode
        String encodedString = Base64.getEncoder().encodeToString(originalString.getBytes());
        System.out.println("Encoded String: " + encodedString);
        
        // Decode
        byte[] decodedBytes = Base64.getDecoder().decode(encodedString);
        String decodedString = new String(decodedBytes);
        System.out.println("Decoded String: " + decodedString);
    }
}

Explanation

Encoding: Base64.getEncoder().encodeToString(originalString.getBytes()) encodes the originalString to Base64.
Decoding: Base64.getDecoder().decode(encodedString) decodes the Base64 string back to bytes, which are then converted to a string.

Output

Encoded String: SGVsbG8sIFdvcmxkIQ==
Decoded String: Hello, World!

2. Encoding and Decoding with URL and Filename Safe Base64

The URL-safe encoder replaces the + and / characters with – and _, making the encoded string safe for URLs and filenames.

Example: URL-Safe Encoding and Decoding

import java.util.Base64;

public class Base64UrlExample {
    public static void main(String[] args) {
        String originalString = "Hello, URL-safe World!";
        
        // Encode using URL-safe Base64 encoder
        String encodedUrlString = Base64.getUrlEncoder().encodeToString(originalString.getBytes());
        System.out.println("URL-Safe Encoded String: " + encodedUrlString);
        
        // Decode
        byte[] decodedBytes = Base64.getUrlDecoder().decode(encodedUrlString);
        String decodedString = new String(decodedBytes);
        System.out.println("Decoded String: " + decodedString);
    }
}

Explanation

URL Encoding: Base64.getUrlEncoder().encodeToString() encodes the string using a URL-safe Base64 variant.
URL Decoding: Base64.getUrlDecoder().decode() decodes the URL-safe Base64 string back to the original text.

Output

URL-Safe Encoded String: SGVsbG8sIFVSTC1zYWZlIFdvcmxkIQ==
Decoded String: Hello, URL-safe World!

3. MIME Base64 Encoding with Line Breaks

The MIME encoder inserts line breaks every 76 characters, which is suitable for encoding large data like files or images in MIME format for emails.

Example: MIME Encoding and Decoding

import java.util.Base64;

public class Base64MimeExample {
    public static void main(String[] args) {
        String originalString = "This is a long string that might need to be split into multiple lines for MIME encoding purposes.";

        // Encode with MIME Base64 encoder
        String encodedMimeString = Base64.getMimeEncoder().encodeToString(originalString.getBytes());
        System.out.println("MIME Encoded String: " + encodedMimeString);
        
        // Decode
        byte[] decodedBytes = Base64.getMimeDecoder().decode(encodedMimeString);
        String decodedString = new String(decodedBytes);
        System.out.println("Decoded String: " + decodedString);
    }
}

Explanation

MIME Encoding: Base64.getMimeEncoder().encodeToString() encodes the string and adds line breaks every 76 characters.
MIME Decoding: Base64.getMimeDecoder().decode() decodes the MIME Base64-encoded string back to the original text.

Output

MIME Encoded String: VGhpcyBpcyBhIGxvbmcgc3RyaW5nIHRoYXQgbWlnaHQgbmVlZCB0byBiZSBzcGxpdCBp
bnRvIG11bHRpcGxlIGxpbmVzIGZvciBNSU1FIGVuY29kaW5nIHB1cnBvc2VzLg==
Decoded String: This is a long string that might need to be split into multiple lines for MIME encoding purposes.

4. Encoding and Decoding Binary Data (e.g., Image Files)

Base64 encoding is often used to encode binary data for transmission or storage. This example demonstrates encoding an image file into a Base64 string and decoding it back to the original format.

Example: Encoding and Decoding an Image File

import java.util.Base64;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;

public class Base64BinaryExample {
    public static void main(String[] args) {
        try {
            // Load the image file as bytes
            byte[] fileContent = Files.readAllBytes(Paths.get("example.png"));

            // Encode the bytes into a Base64 string
            String encodedString = Base64.getEncoder().encodeToString(fileContent);
            System.out.println("Encoded Image String: " + encodedString);

            // Decode the Base64 string back to bytes
            byte[] decodedBytes = Base64.getDecoder().decode(encodedString);

            // Write the decoded bytes to a new file
            Files.write(Paths.get("decoded_example.png"), decodedBytes);
            System.out.println("Image successfully decoded and saved as 'decoded_example.png'");
        } catch (IOException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Explanation

Encoding: Files.readAllBytes(Paths.get(“example.png”)) reads the binary content of an image file. We then encode it using Base64.getEncoder().encodeToString().
Decoding: Base64.getDecoder().decode(encodedString) converts the Base64 string back into bytes, which are saved as a new image file.

5. Customizing MIME Encoding with Line Length and Line Separator

The Base64.getMimeEncoder() allows you to specify a custom line length and line separator. This can be useful when working with protocols or systems that require specific formatting.

Example: Custom MIME Encoding with Line Length and Separator

import java.util.Base64;

public class Base64CustomMimeExample {
    public static void main(String[] args) {
        String originalString = "This is a custom MIME encoding example that requires specific line lengths and separators.";

        // Customize line length to 50 characters and use "#" as the line separator
        Base64.Encoder mimeEncoder = Base64.getMimeEncoder(50, "#".getBytes());

        // Encode the string
        String encodedString = mimeEncoder.encodeToString(originalString.getBytes());
        System.out.println("Custom MIME Encoded String:\n" + encodedString);
    }
}

Explanation

Custom MIME Encoding: Base64.getMimeEncoder(50, “#”.getBytes()) encodes the string with a custom line length of 50 characters and uses # as the line separator.
The output is formatted with line breaks and custom separators.

6. Encoding and Decoding Objects Using Serialization

Base64 can be used to encode objects by serializing them into a byte array, then encoding the byte array to a Base64 string.

Example: Serializing and Encoding an Object to Base64

import java.util.Base64;
import java.io.*;

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

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

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

public class Base64ObjectExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        
        try {
            // Serialize and encode the object to Base64
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(person);
            objectOutputStream.close();

            String encodedObject = Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray());
            System.out.println("Encoded Object: " + encodedObject);

            // Decode and deserialize the object from Base64
            byte[] decodedBytes = Base64.getDecoder().decode(encodedObject);
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(decodedBytes);
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            Person decodedPerson

 = (Person) objectInputStream.readObject();
            objectInputStream.close();

            System.out.println("Decoded Object: " + decodedPerson);
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Explanation

Serialization: We serialize the Person object to a byte array and then encode it to a Base64 string.
Deserialization: We decode the Base64 string back to bytes and then deserialize it to a Person object.

Summary

Java’s Base64 class provides a robust way to handle Base64 encoding and decoding.

Key points include:

Basic Encoding: Used for general-purpose encoding, with no line breaks.
URL and Filename Safe Encoding: Uses URL-safe characters, making the output suitable for URLs and filenames.
MIME Encoding: Adds line breaks, making it suitable for large data and MIME-based applications.
Binary Data: Useful for encoding binary files like images or documents.
Object Serialization: Enables encoding of objects by serializing them to a byte array.

By mastering these methods, you can securely and efficiently handle data transmission and storage requirements in Java applications.

November 4, 2024 0 comment

Advanced

Java Regular Expressions tutorial with Examples

written by 75ypsaw71

Regular Expressions (Regex) in Java provide a powerful way to search, match, and manipulate strings.

They are part of the java.util.regex package and allow you to use patterns to locate, extract, and replace specific text patterns within strings.

In this tutorial, we will cover:

Basic Usage of Regular Expressions in Java
Common Regex Patterns and Examples
Using Pattern and Matcher Classes for Matching
Search and Replace with Regex
Splitting Strings Using Regex

Let's explore each section with examples.

1. Basic Usage of Regular Expressions in Java

Java provides the Pattern and Matcher classes for handling regex operations.

The Pattern class compiles a regex pattern, while the Matcher class applies the pattern to a target string.

Example 1: Basic Matching

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class BasicRegexExample {
    public static void main(String[] args) {
        String text = "Java is a powerful programming language.";
        String pattern = "powerful";

        // Compile the pattern
        Pattern compiledPattern = Pattern.compile(pattern);
        
        // Create a matcher to search for the pattern
        Matcher matcher = compiledPattern.matcher(text);
        
        if (matcher.find()) {
            System.out.println("Match found!");
        } else {
            System.out.println("No match found.");
        }
    }
}

Explanation: This example checks if the word “powerful” exists in the text string. matcher.find() returns true if a match is found.

2. Common Regex Patterns and Examples

Java regular expressions follow the same basic syntax as other languages.

Here are some common patterns:

Pattern	Description	Example
.	Any character	a.c matches “abc”, “adc”
\d	Any digit (0-9)	\d matches “3” in “123abc”
\D	Any non-digit	\D matches “a” in “123abc”
\w	Any word character (a-z, A-Z, 0-9, _)	\w+ matches “abc123”
\s	Any whitespace character	\s matches space in “a b”
[abc]	Any character in set	[aeiou] matches “a” in “cat”
[^abc]	Any character not in set	[^aeiou] matches “c” in “cat”
`a	b`	Either a or b
*, +, ?	Zero or more, one or more, zero or one	a*, a+, a?
{n,m}	Between n and m repetitions	a{2,4} matches “aa”, “aaa”

Example 2: Using Common Patterns to Match Strings

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class PatternExample {
    public static void main(String[] args) {
        String text = "Contact us at info@example.com or visit www.example.com";
        String emailPattern = "\\w+@\\w+\\.\\w+";  // Email pattern
        String urlPattern = "www\\.\\w+\\.\\w+";   // URL pattern

        // Match email
        Matcher emailMatcher = Pattern.compile(emailPattern).matcher(text);
        if (emailMatcher.find()) {
            System.out.println("Email found: " + emailMatcher.group());
        }

        // Match URL
        Matcher urlMatcher = Pattern.compile(urlPattern).matcher(text);
        if (urlMatcher.find()) {
            System.out.println("URL found: " + urlMatcher.group());
        }
    }
}

Output:

Email found: info@example.com
URL found: www.example.com

Explanation: The email pattern \\w+@\\w+\\.\\w+ matches a basic email format, and the URL pattern www\\.\\w+\\.\\w+ matches web addresses starting with www.

3. Using Pattern and Matcher Classes for Matching

The Pattern and Matcher classes provide methods like matches(), find(), and group() for working with regular expressions.

Example 3: Extracting Groups with Pattern and Matcher

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class GroupExample {
    public static void main(String[] args) {
        String text = "User: JohnDoe, Email: john.doe@example.com";
        String pattern = "(\\w+): (\\w+), Email: (\\w+\\.\\w+@\\w+\\.\\w+)";

        Matcher matcher = Pattern.compile(pattern).matcher(text);

        if (matcher.find()) {
            System.out.println("Username: " + matcher.group(2));
            System.out.println("Email: " + matcher.group(3));
        }
    }
}

Output:

Username: JohnDoe
Email: john.doe@example.com

Explanation: Using parentheses in the pattern (…) creates capturing groups. matcher.group(2) extracts the username, and matcher.group(3) extracts the email.

4. Search and Replace with Regex

The replaceAll() method allows you to replace matched patterns with a specific string.

Example 4: Replacing Words in a String

public class ReplaceExample {
    public static void main(String[] args) {
        String text = "Java is great. Java is powerful.";
        String updatedText = text.replaceAll("Java", "Python");

        System.out.println("Updated text: " + updatedText);
    }
}

Output:

Updated text: Python is great. Python is powerful.

Explanation: This example replaces all occurrences of “Java” with “Python” using replaceAll().

Example 5: Using Regex in Replace to Format a String

public class FormatExample {
    public static void main(String[] args) {
        String text = "UserID123";
        String formattedText = text.replaceAll("(UserID)(\\d+)", "$1-#$2");

        System.out.println("Formatted text: " + formattedText);
    }
}

Output:

Formatted text: UserID-#123

Explanation: Using replaceAll() with () captures groups in the pattern and replaces them in the output. $1 and $2 reference the groups.

5. Splitting Strings Using Regex

You can split a string into parts based on a regex pattern with split().

Example 6: Splitting a String by Multiple Delimiters

import java.util.Arrays;

public class SplitExample {
    public static void main(String[] args) {
        String text = "apple,orange;banana|grape";
        String[] fruits = text.split("[,;|]");

        System.out.println("Fruits: " + Arrays.toString(fruits));
    }
}

Output:

Fruits: [apple, orange, banana, grape]

Explanation: The pattern [ ,;|] matches commas, semicolons, or vertical bars, and split() divides the string based on any of these delimiters.

Example 7: Splitting a String by Whitespace and Trimming Extra Spaces

public class SplitTrimExample {
    public static void main(String[] args) {
        String text = " Java    is  powerful ";
        String[] words = text.trim().split("\\s+");

        for (String word : words) {
            System.out.println(word);
        }
    }
}

Output:

Java
is
powerful

Explanation: The split(“\\s+”) pattern splits by one or more whitespace characters, and trim() removes leading and trailing spaces.

Summary of Regular Expressions in Java

Regex Function	Description
Pattern.compile()	Compiles a regex pattern.
matcher()	Creates a Matcher instance for applying the pattern.
find()	Searches for the next match of the pattern in the text.
matches()	Checks if the entire text matches the regex pattern.
group()	Returns matched groups from the pattern using capturing groups.
replaceAll()	Replaces all matches in the text with a specified replacement.
split()	Splits text into an array based on the regex pattern.

Conclusion

In this tutorial, we explored various ways to use regular expressions in Java, including:

Basic pattern matching with Pattern and Matcher.
Common regex patterns for matching strings.
Extracting groups from matches.
Using regex to search and replace text.
Splitting text based on complex patterns.

October 25, 2024 0 comment

Advanced

Understanding JVM Shutdown Hooks tutorial

written by 75ypsaw71

Table of Contents

What is a Shutdown Hook?

A Shutdown Hook is a thread that is registered with the JVM to be executed when the JVM is shutting down. The shutdown can occur due to:

The program exiting normally (e.g., by reaching the end of the main method or calling System.exit(0)).
The program being terminated by external signals (e.g., user interrupts like pressing Ctrl+C).
The JVM shutting down due to a failure (e.g., due to an error that cannot be recovered).

When is a Shutdown Hook Not Executed?

Shutdown hooks are not guaranteed to execute in the following scenarios:

If the JVM is abruptly terminated using methods like Runtime.halt() or System.halt().
If the underlying operating system forcibly kills the JVM process (e.g., using kill -9 on Unix/Linux systems).
If there is a fatal error that causes the JVM to crash (e.g., segmentation fault).

2. How to Register a Shutdown Hook

To register a shutdown hook in Java, you need to:

Create a class that extends Thread or implements Runnable, containing the code you want to execute during shutdown.
Register the shutdown hook using the Runtime.getRuntime().addShutdownHook(Thread hook) method.

Example:

Thread shutdownHook = new Thread(() -> {
    // Code to execute during shutdown
});

Runtime.getRuntime().addShutdownHook(shutdownHook);

3. Code Examples Demonstrating Shutdown Hooks

Example 1: Basic Shutdown Hook

Let's create a simple example where we register a shutdown hook that prints a message when the JVM shuts down.

public class ShutdownHookExample {
    public static void main(String[] args) {
        // Registering the shutdown hook
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("Shutdown Hook is running!");
        }));

        System.out.println("Application is running...");
        try {
            Thread.sleep(3000);  // Simulate some work
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Application is exiting...");
    }
}

Explanation:

The shutdown hook is registered using Runtime.getRuntime().addShutdownHook().
When the application is terminated (normally or by user interrupt), the shutdown hook executes and prints the message.

Output:

Application is running...
Application is exiting...
Shutdown Hook is running!

Example 2: Cleanup Resources During Shutdown

In this example, we'll simulate opening a resource (like a file or database connection) and ensure it's properly closed during shutdown.

public class ResourceCleanupExample {
    public static void main(String[] args) {
        // Simulate opening a resource
        Resource resource = new Resource();

        // Registering the shutdown hook to clean up the resource
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            resource.close();
        }));

        System.out.println("Application is running...");
        try {
            Thread.sleep(5000);  // Simulate some work
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Application is exiting...");
    }
}

class Resource {
    public Resource() {
        System.out.println("Resource opened.");
    }

    public void close() {
        System.out.println("Resource closed.");
    }
}

Explanation:

A Resource class simulates a resource that needs to be closed.
The shutdown hook ensures that resource.close() is called during shutdown.
Even if the application is interrupted, the resource will be properly closed.

Output:

Resource opened.
Application is running...
Application is exiting...
Resource closed.

Example 3: Handling User Interrupts (Ctrl+C)

This example demonstrates how shutdown hooks can handle user interrupts (e.g., pressing Ctrl+C in the console).

public class UserInterruptExample {
    public static void main(String[] args) {
        // Registering the shutdown hook
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("\nShutdown Hook triggered by user interrupt.");
            System.out.println("Performing cleanup...");
        }));

        System.out.println("Application is running. Press Ctrl+C to exit.");
        while (true) {
            try {
                Thread.sleep(1000);  // Keep the application running
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Explanation:

The application runs indefinitely until interrupted.
When the user presses Ctrl+C, the shutdown hook is triggered, and cleanup code is executed.
Output (after pressing Ctrl+C):

Application is running. Press Ctrl+C to exit.
^C
Shutdown Hook triggered by user interrupt.
Performing cleanup...

Example 4: Ordering Multiple Shutdown Hooks

If multiple shutdown hooks are registered, they are executed in an unspecified order. However, you can manage dependencies between hooks by ensuring that the code within each hook handles synchronization appropriately.

public class MultipleShutdownHooksExample {
    public static void main(String[] args) {
        // First shutdown hook
        Thread hook1 = new Thread(() -> {
            System.out.println("Shutdown Hook 1 is running.");
        });

        // Second shutdown hook
        Thread hook2 = new Thread(() -> {
            System.out.println("Shutdown Hook 2 is running.");
        });

        // Registering the shutdown hooks
        Runtime.getRuntime().addShutdownHook(hook1);
        Runtime.getRuntime().addShutdownHook(hook2);

        System.out.println("Application is running...");
        try {
            Thread.sleep(2000);  // Simulate some work
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Application is exiting...");
    }
}

Explanation:

Two shutdown hooks (hook1 and hook2) are registered.
The order in which they execute is not guaranteed.
It's important to design your hooks to be independent of execution order.

Possible Output:

Application is running...
Application is exiting...
Shutdown Hook 2 is running.
Shutdown Hook 1 is running.

Note: The execution order may vary between runs.

Example 5: Removing a Shutdown Hook

You can remove a previously registered shutdown hook using the Runtime.getRuntime().removeShutdownHook(Thread hook) method.

public class RemoveShutdownHookExample {
    public static void main(String[] args) {
        Thread hook = new Thread(() -> {
            System.out.println("Shutdown Hook is running.");
        });

        // Registering the shutdown hook
        Runtime.getRuntime().addShutdownHook(hook);

        System.out.println("Application is running...");

        // Decide to remove the shutdown hook
        if (someCondition()) {
            boolean removed = Runtime.getRuntime().removeShutdownHook(hook);
            if (removed) {
                System.out.println("Shutdown Hook removed.");
            } else {
                System.out.println("Failed to remove Shutdown Hook.");
            }
        }

        try {
            Thread.sleep(2000);  // Simulate some work
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Application is exiting...");
    }

    private static boolean someCondition() {
        // Simulate a condition (e.g., user input or configuration)
        return true;
    }
}

Explanation:

The shutdown hook is registered but then conditionally removed.
The removeShutdownHook() method returns true if the hook was successfully removed.
If the shutdown hook is removed, it will not execute during shutdown.

Output:

Application is running...
Shutdown Hook removed.
Application is exiting...

Note: Since the shutdown hook was removed, it does not execute during shutdown.

Example 6: Shutdown Hook with System.exit()

When System.exit(int status) is called, the JVM initiates an orderly shutdown, and registered shutdown hooks are executed.

public class SystemExitExample {
    public static void main(String[] args) {
        // Registering the shutdown hook
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("Shutdown Hook is running.");
        }));

        System.out.println("Application is running...");
        try {
            Thread.sleep(1000);  // Simulate some work
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Calling System.exit(0)...");
        System.exit(0);

        // This line will not be executed
        System.out.println("This line will not be printed.");
    }
}

Explanation:

The System.exit(0) method terminates the JVM.
Before shutting down, the JVM executes all registered shutdown hooks.
Any code after System.exit() is not executed.

Output:

Application is running...
Calling System.exit(0)...
Shutdown Hook is running.

4. Key Considerations and Best Practices

1. Keep Shutdown Hooks Simple

Avoid Long-running Tasks: Shutdown hooks should complete quickly to avoid delaying the JVM shutdown.
Avoid Deadlocks: Be cautious with synchronization and shared resources to prevent deadlocks during shutdown.
Avoid Creating New Threads: Starting new threads in a shutdown hook is discouraged, as they may not get a chance to execute.

2. Exception Handling

Handle Exceptions: Exceptions thrown in a shutdown hook may prevent other hooks from executing. Always handle exceptions within your hooks.

Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    try {
        // Code that might throw an exception
    } catch (Exception e) {
        e.printStackTrace();
    }
}));

3. Do Not Rely on Execution Order

Unspecified Order: If multiple shutdown hooks are registered, their execution order is not guaranteed.
Design Hooks Independently: Ensure that your shutdown hooks do not depend on the execution order or on each other.

4. Limitations

Cannot Stop Shutdown: Shutdown hooks cannot stop the JVM from shutting down.
Not for Regular Termination Logic: Do not use shutdown hooks as a replacement for proper application termination logic.

5. Removing Shutdown Hooks

Timing Matters: You cannot remove a shutdown hook once the shutdown sequence has begun.
Use Cases for Removal: Removing a shutdown hook might be necessary if the application state changes and the hook is no longer needed.

5. Conclusion

Java Shutdown Hooks provide a powerful mechanism for executing code during the JVM shutdown sequence. They are particularly useful for cleaning up resources, saving state, or performing other essential tasks that should occur regardless of how the application exits.

When using shutdown hooks:

Register hooks responsibly and ensure they complete promptly.
Handle exceptions within your hooks to prevent interference with other hooks.
Design your hooks to be independent of execution order.
Be aware of the limitations and ensure that critical application logic is not solely dependent on shutdown hooks.

By understanding and applying these best practices, you can effectively utilize shutdown hooks to enhance the reliability and robustness of your Java applications.

October 11, 2024 0 comment

Advanced

Java Daemon Threads Tutorial

written by 75ypsaw71

In Java, threads are classified into two categories: user threads and daemon threads.

While user threads are designed to perform tasks that need to be completed before the program exits, daemon threads are background threads that provide support to other user threads, and their life cycle is tied to the life of user threads. Once all user threads are finished, the JVM automatically terminates all daemon threads.

Daemon threads are typically used for background tasks like garbage collection, monitoring services, and other tasks that do not require the program to wait for their completion.

Table of Contents

In this tutorial, we will cover:

The concept of daemon threads and their lifecycle.
How to create and use daemon threads in Java.
Code examples demonstrating common daemon thread use cases.

1. What is a Daemon Thread?

A daemon thread is a low-priority thread that runs in the background, performing support tasks such as resource cleanup. Daemon threads are automatically terminated when all user threads (non-daemon threads) finish their execution.

Key characteristics of daemon threads:

Background nature: Daemon threads run in the background and do not prevent the JVM from exiting.
JVM termination: When only daemon threads are left running, the JVM exits and does not wait for them to finish.
Use cases: Typically used for background tasks such as monitoring, logging, and garbage collection.

2. How to Create a Daemon Thread

In Java, any thread can be made a daemon thread by calling setDaemon(true) before the thread is started. The isDaemon() method can be used to check if a thread is a daemon thread.

Steps to create a daemon thread:
Create a thread using the Thread class or by implementing the Runnable interface.
Before starting the thread, call the setDaemon(true) method to mark the thread as a daemon.
Start the thread using the start() method.

3. Daemon Thread Example:

Example 1: Simple Daemon Thread

public class SimpleDaemonThreadExample {
    public static void main(String[] args) {
        // Creating a thread
        Thread daemonThread = new Thread(new DaemonTask());

        // Setting the thread as a daemon thread
        daemonThread.setDaemon(true);

        // Starting the daemon thread
        daemonThread.start();

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

        // When the main thread exits, the JVM terminates the daemon thread
        System.out.println("Main thread finished.");
    }
}

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

Explanation:

The thread running the DaemonTask is marked as a daemon using setDaemon(true).
The main thread sleeps for 2 seconds and then terminates.
When the main thread exits, the daemon thread is automatically terminated, even though it is running an infinite loop.

Example 2: Mixing User and Daemon Threads

In this example, we create both user and daemon threads to observe how the JVM behaves when the user threads complete.

public class UserAndDaemonThreadExample {
    public static void main(String[] args) {
        // User thread
        Thread userThread = new Thread(new UserTask());
        userThread.setDaemon(false);  // Explicitly set as a user thread (optional, as it's false by default)
        
        // Daemon thread
        Thread daemonThread = new Thread(new DaemonTask());
        daemonThread.setDaemon(true);  // Set as a daemon thread

        // Starting both threads
        userThread.start();
        daemonThread.start();

        // Main thread will wait for the user thread to finish
        try {
            userThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

class UserTask implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("User thread iteration " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("User thread finished.");
    }
}

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

Explanation:

User thread (UserTask): Runs for 5 iterations, with a 1-second sleep between iterations.
Daemon thread (DaemonTask): Runs an infinite loop, but it will be terminated automatically once the user thread completes.
The userThread.join() ensures that the main thread waits for the user thread to finish before terminating.
The daemon thread continues running until the user thread finishes, at which point the JVM shuts down.

4. Important Methods for Daemon Threads

Here are some important methods related to daemon threads:

setDaemon(boolean on): Sets the thread as a daemon thread if on is true. This method must be called before starting the thread.
isDaemon(): Returns true if the thread is a daemon thread, false otherwise.

Example 3: Checking if a Thread is a Daemon Thread

public class DaemonThreadCheckExample {
    public static void main(String[] args) {
        // Creating a daemon thread
        Thread daemonThread = new Thread(new DaemonTask());
        daemonThread.setDaemon(true);

        // Checking if the thread is a daemon thread
        System.out.println("Is daemonThread a daemon? " + daemonThread.isDaemon());  // true

        // Creating a user thread
        Thread userThread = new Thread(new UserTask());

        // Checking if the thread is a user thread
        System.out.println("Is userThread a daemon? " + userThread.isDaemon());  // false

        daemonThread.start();
        userThread.start();
    }
}

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

class UserTask implements Runnable {
    @Override
    public void run() {
        System.out.println("User thread is running.");
    }
}

Explanation:

The isDaemon() method is used to check whether a thread is a daemon or not.
In this example, daemonThread is a daemon thread (true), while userThread is a normal user thread (false).

5. Use Cases for Daemon Threads

Daemon threads are suitable for tasks that do not require the program to wait for their completion. Some common use cases include:

Background Monitoring: Daemon threads can be used for monitoring services, such as logging, system health monitoring, or performance tracking.
Garbage Collection: The JVM’s garbage collector is a daemon thread that automatically runs in the background.
Resource Cleanup: Daemon threads can handle tasks like temporary file deletion, memory cleanup, and other maintenance tasks.

Example 4: Daemon Thread for Logging

public class LoggingDaemonThreadExample {
    public static void main(String[] args) {
        // Creating and starting the logging daemon thread
        Thread loggingThread = new Thread(new LoggingTask());
        loggingThread.setDaemon(true);  // Set the thread as a daemon thread
        loggingThread.start();

        // Simulate main application work
        for (int i = 1; i <= 3; i++) {
            System.out.println("Main application working on task " + i);
            try {
                Thread.sleep(1000);  // Simulating work
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

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

class LoggingTask implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("Logging system is monitoring...");
            try {
                Thread.sleep(2000);  // Simulate background logging work
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Explanation:

The LoggingTask simulates a background logging service that runs periodically.
Since it's marked as a daemon thread, it will terminate once the main application finishes, even if it's still in its loop.

6. Key Considerations for Daemon Threads

Daemon threads do not block JVM termination: The JVM does not wait for daemon threads to complete before exiting. Once all user threads finish, daemon threads are terminated without completing their tasks.
Use daemon threads for background tasks: Daemon threads are ideal for tasks that are not critical to program completion, such as logging, monitoring, and periodic cleanups.
Daemon threads must be set before starting: The setDaemon(true) method must be called before the thread is started. Otherwise, it will throw an IllegalThreadStateException.

Conclusion

In this tutorial, we explored daemon threads in Java, covering:

The concept of daemon threads and how they differ from user threads.
How to create and use daemon threads with setDaemon(true).
Examples that demonstrate how daemon threads work in the context of user threads and JVM termination.
Typical use cases, such as background monitoring, logging, and cleanup tasks.

Daemon threads provide a useful mechanism for handling background tasks that do not need to block the termination of the JVM.

October 11, 2024 0 comment

Advanced

Java Thread Pools Tutorial

written by 75ypsaw71

A Thread Pool in Java is a pool of worker threads that efficiently manage the execution of multiple tasks concurrently.

Instead of creating a new thread every time a task needs to be executed, you can use a thread pool to reuse existing threads, improving performance and resource management, especially when dealing with a large number of short-lived tasks.

The Java Concurrency framework provides a built-in way to manage thread pools via the java.util.concurrent package, particularly using the Executor framework.

Table of Contents

In this tutorial, we will cover:

Overview of thread pools and their benefits.
The ExecutorService interface and its methods.
Different types of thread pools provided by the Executors class.
Code examples demonstrating thread pool usage in different scenarios.

1. Overview of Thread Pools

Why Use a Thread Pool?

Improved Performance: Thread pools can reduce the overhead associated with thread creation and destruction by reusing existing threads.
Resource Management: With a thread pool, the number of concurrent threads can be controlled, preventing issues like memory exhaustion.
Task Queueing: Tasks are submitted to a queue and executed by available threads in the pool. Tasks wait in the queue if all threads are busy.
Scalability: Thread pools can be easily scaled up or down, based on the workload.

2. ExecutorService Interface

The ExecutorService is a higher-level interface for managing threads in a pool. It provides methods to submit tasks, shut down the pool, and manage asynchronous task execution.

Key Methods of ExecutorService:

submit(Runnable task): Submits a task for execution and returns a Future representing the result.
submit(Callable task): Submits a Callable task that returns a value.
shutdown(): Initiates an orderly shutdown of the thread pool, allowing previously submitted tasks to complete.
shutdownNow(): Attempts to stop all actively executing tasks and halts the processing of waiting tasks.
invokeAll(): Executes multiple Callable tasks and returns a list of Future objects representing their results.

3. Types of Thread Pools

The Executors class provides several factory methods to create different types of thread pools:

newFixedThreadPool(int nThreads): Creates a thread pool with a fixed number of threads.
newCachedThreadPool(): Creates a thread pool that creates new threads as needed, but reuses previously created threads if available.
newSingleThreadExecutor(): Creates a thread pool with a single thread.
newScheduledThreadPool(int corePoolSize): Creates a thread pool that supports scheduling commands to run after a delay or periodically.

4. Examples of Using Thread Pools

Example 1: Using newFixedThreadPool()

A Fixed Thread Pool is created with a fixed number of threads. If all threads are busy, new tasks must wait in the queue until a thread becomes available.

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

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        // Creating a fixed thread pool with 3 threads
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // Creating 5 tasks
        for (int i = 1; i <= 5; i++) {
            Runnable task = new Task(i);
            executorService.execute(task);  // Submitting tasks for execution
        }

        // Initiating shutdown after all tasks are submitted
        executorService.shutdown();
    }
}

class Task implements Runnable {
    private final int taskId;

    public Task(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);  // Simulate work
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task " + taskId + " completed by " + Thread.currentThread().getName());
    }
}

Explanation:

A fixed thread pool with 3 threads is created. Only 3 tasks can run concurrently, while others wait.
Each task simulates work by sleeping for 2 seconds.
shutdown() is called to stop accepting new tasks and allows the previously submitted tasks to complete.

Example 2: Using newCachedThreadPool()

A Cached Thread Pool dynamically creates new threads if no existing thread is available. Threads that have completed their tasks are reused for new tasks.

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

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        // Creating a cached thread pool
        ExecutorService executorService = Executors.newCachedThreadPool();

        // Submitting 5 tasks
        for (int i = 1; i <= 5; i++) {
            Runnable task = new Task(i);
            executorService.execute(task);
        }

        // Shutting down the executor service
        executorService.shutdown();
    }
}

class Task implements Runnable {
    private final int taskId;

    public Task(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);  // Simulate work
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task " + taskId + " completed by " + Thread.currentThread().getName());
    }
}

Explanation:

The cached thread pool creates new threads as needed but reuses threads that have completed previous tasks.
If there are idle threads, they are reused instead of creating new ones.
Ideal for applications with a large number of short-lived tasks.

Example 3: Using newSingleThreadExecutor()

A Single Thread Executor ensures that tasks are executed sequentially in a single thread, one after the other.

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

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        // Creating a single-thread executor
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        // Submitting 3 tasks
        for (int i = 1; i <= 3; i++) {
            Runnable task = new Task(i);
            executorService.execute(task);
        }

        // Shutting down the executor service
        executorService.shutdown();
    }
}

class Task implements Runnable {
    private final int taskId;

    public Task(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);  // Simulate work
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Task " + taskId + " completed by " + Thread.currentThread().getName());
    }
}

Explanation:

A single-thread executor executes tasks sequentially in the same thread, ensuring that only one task is running at any given time.
Useful for scenarios where tasks must be performed in sequence.

Example 4: Using Callable and Future with Thread Pool

You can submit a Callable to a thread pool, which allows the task to return a result. The result of a Callable is retrieved using a Future object.

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

public class CallableFutureExample {
    public static void main(String[] args) throws Exception {
        // Creating a fixed thread pool with 2 threads
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        // Submitting two Callable tasks
        Future result1 = executorService.submit(new Task("Task 1"));
        Future result2 = executorService.submit(new Task("Task 2"));

        // Getting the results of the Callable tasks
        System.out.println(result1.get());  // Output of Task 1
        System.out.println(result2.get());  // Output of Task 2

        // Shutting down the executor service
        executorService.shutdown();
    }
}

class Task implements Callable {
    private final String taskName;

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

    @Override
    public String call() throws Exception {
        System.out.println(taskName + " is being executed by " + Thread.currentThread().getName());
        Thread.sleep(1000);  // Simulate work
        return taskName + " completed";
    }
}

Explanation:

Callable is used to define tasks that return a result.
submit(Callable) submits the task, and a Future object is returned, representing the task's result.
Future.get() blocks the calling thread until the result of the Callable is available.

Example 5: Using newScheduledThreadPool() for Scheduled Tasks

A Scheduled Thread Pool is used to schedule tasks to run after a delay or at fixed intervals.

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        // Creating a scheduled thread pool with 2 threads
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);

        // Scheduling a task to run after 3 seconds
        scheduledExecutorService.schedule(new Task(1), 3, TimeUnit.SECONDS);

        // Scheduling a task to run periodically every 2 seconds, starting after 1 second
        scheduledExecutorService.scheduleAtFixedRate(new Task(2), 1, 2, TimeUnit.SECONDS);

        // Shutting down after 10 seconds
        scheduledExecutorService.schedule(() -> {
            scheduledExecutorService.shutdown();
        }, 10, TimeUnit.SECONDS);
    }
}

class Task implements Runnable {
    private final int taskId;

    public Task(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
    }
}

Explanation:

schedule(): Schedules a task to execute after a specified delay.
scheduleAtFixedRate(): Schedules a task to execute periodically, with a fixed delay between successive executions.
The scheduled thread pool is useful for tasks that need to run at regular intervals or after a specific delay.

6. Key Considerations for Thread Pools

Thread Reuse: Thread pools reuse threads for multiple tasks, reducing the overhead of thread creation and destruction.
Resource Management: By limiting the number of threads, you can prevent resource exhaustion (e.g., running out of memory due to too many threads).
Shutdown: Always remember to shut down the thread pool using shutdown() to release resources after task execution is complete.

Conclusion

In this tutorial, we explored the Thread Pool concept in Java and how to manage concurrent tasks using the ExecutorService interface and various thread pool implementations provided by the Executors class. We covered:

Fixed thread pools, cached thread pools, and single-threaded executors.
Submitting both Runnable and Callable tasks to the thread pool.
Scheduling tasks using a scheduled thread pool.

Thread pools are a powerful mechanism for efficiently managing concurrent tasks in multi-threaded Java applications.

October 11, 2024 0 comment

Advanced

Java Inter-thread Communication Tutorial

written by 75ypsaw71

In Java, inter-thread communication refers to the process where threads can communicate with each other, allowing them to coordinate their work.

It is often used in scenarios where one thread produces data and another thread consumes that data (producer-consumer problems).

Java provides built-in mechanisms to achieve inter-thread communication using methods like wait(), notify(), and notifyAll(), which work with synchronization to ensure safe communication between threads.

In this tutorial, we will explore these concepts with examples to demonstrate how threads communicate with each other in Java.

Table of Contents

1. Key Methods for Inter-thread Communication

Java provides three key methods from the Object class that are essential for inter-thread communication:

wait(): Causes the current thread to wait until another thread calls notify() or notifyAll() on the same object.
notify(): Wakes up a single thread that is waiting on the object's monitor.
notifyAll(): Wakes up all the threads that are waiting on the object's monitor.
These methods are always used within a synchronized block or synchronized method to ensure that only one thread can access the shared resource at a time.

2. Understanding wait(), notify(), and notifyAll()

wait(): When a thread calls wait(), it releases the lock on the object and enters a waiting state until another thread calls notify() or notifyAll() on the same object.
notify(): Wakes up one waiting thread (chosen randomly) that is waiting on the object's monitor. If no threads are waiting, nothing happens.
notifyAll(): Wakes up all the threads waiting on the object's monitor. The threads will compete to acquire the lock once it is available.

3. Producer-Consumer Problem (Basic Example)

A classic use case for inter-thread communication is the producer-consumer problem, where one thread (producer) generates data and another thread (consumer) processes it.

The producer should wait if the shared resource (buffer) is full, and the consumer should wait if the buffer is empty.

Example: Producer-Consumer with wait() and notify()

class SharedResource {
    private int value;
    private boolean hasValue = false;  // To track if value is produced

    // Synchronized method for producing a value
    public synchronized void produce(int newValue) throws InterruptedException {
        // Wait if the value has already been produced
        while (hasValue) {
            wait();
        }
        this.value = newValue;
        System.out.println("Produced: " + newValue);
        hasValue = true;  // Mark that the value has been produced
        notify();  // Notify the consumer
    }

    // Synchronized method for consuming a value
    public synchronized void consume() throws InterruptedException {
        // Wait if there is no value to consume
        while (!hasValue) {
            wait();
        }
        System.out.println("Consumed: " + value);
        hasValue = false;  // Mark that the value has been consumed
        notify();  // Notify the producer
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();

        // Producer thread
        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) { resource.produce(i); Thread.sleep(100); // Simulate some work } } catch (InterruptedException e) { e.printStackTrace(); } }); // Consumer thread Thread consumer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    resource.consume();
                    Thread.sleep(150);  // Simulate some work
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Start both threads
        producer.start();
        consumer.start();
    }
}

Explanation:

The SharedResource class has two synchronized methods: produce() and consume().
The producer produces values (1 to 5), and the consumer consumes them.

If the producer has already produced a value, it waits until the consumer consumes it. Similarly, the consumer waits until the producer produces a new value.

Output:

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

4. Using notifyAll()

In cases where multiple threads are waiting for a resource, notifyAll() can be used to wake up all the waiting threads. Once all threads are awakened, they will compete to acquire the lock and proceed with their work.

Example: Producer-Consumer with Multiple Consumers (notifyAll())

class SharedResourceMultiConsumer {
    private int value;
    private boolean hasValue = false;

    // Synchronized method for producing a value
    public synchronized void produce(int newValue) throws InterruptedException {
        while (hasValue) {
            wait();
        }
        this.value = newValue;
        System.out.println("Produced: " + newValue);
        hasValue = true;
        notifyAll();  // Notify all consumers
    }

    // Synchronized method for consuming a value
    public synchronized void consume(String consumerName) throws InterruptedException {
        while (!hasValue) {
            wait();
        }
        System.out.println(consumerName + " consumed: " + value);
        hasValue = false;
        notifyAll();  // Notify producer
    }
}

public class MultiConsumerExample {
    public static void main(String[] args) {
        SharedResourceMultiConsumer resource = new SharedResourceMultiConsumer();

        // Producer thread
        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) { resource.produce(i); Thread.sleep(100); } } catch (InterruptedException e) { e.printStackTrace(); } }); // Consumer threads Thread consumer1 = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) { resource.consume("Consumer 1"); } } catch (InterruptedException e) { e.printStackTrace(); } }); Thread consumer2 = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    resource.consume("Consumer 2");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Start threads
        producer.start();
        consumer1.start();
        consumer2.start();
    }
}

Explanation:

notifyAll() is used to wake up all waiting consumers after a value is produced.
Once consumers are notified, they compete to acquire the lock and consume the value.

Sample Output (may vary):

Produced: 1
Consumer 1 consumed: 1
Produced: 2
Consumer 2 consumed: 2
Produced: 3
Consumer 1 consumed: 3
Produced: 4
Consumer 2 consumed: 4
Produced: 5
Consumer 1 consumed: 5

5. The wait() and notify() in the Context of Locks

The wait(), notify(), and notifyAll() methods are tightly coupled with synchronization in Java. They must always be called within a synchronized block, as the calling thread must own the lock on the object before invoking these methods.

Example: Incorrect Use of wait() without Synchronization

class IncorrectSharedResource {
    public void produce() throws InterruptedException {
        wait();  // This will throw IllegalMonitorStateException
    }

    public void consume() {
        notify();
    }
}

public class IncorrectUsageExample {
    public static void main(String[] args) {
        IncorrectSharedResource resource = new IncorrectSharedResource();

        Thread producer = new Thread(() -> {
            try {
                resource.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer = new Thread(resource::consume);

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

Explanation:

This code will throw IllegalMonitorStateException because wait() and notify() are being called outside a synchronized block.
You must always use these methods within a synchronized context to avoid such exceptions.

Correct Usage:

synchronized (this) {
    wait();  // Safe usage
}

6. Best Practices for Inter-thread Communication

Always use wait(), notify(), and notifyAll() inside synchronized blocks or synchronized methods.
Use notifyAll() when multiple threads are waiting on the same object to avoid starvation.
Avoid holding multiple locks while using wait() and notify() to reduce the chances of deadlocks.
Always use a while loop for the condition check in wait() to avoid spurious wakeups, which are rare but possible.

7. Real-World Scenario: Bounded Buffer (Producer-Consumer)

In real-world systems, there’s often a bounded buffer (like a queue) between the producer and consumer. The producer cannot add to the buffer if it is full, and the consumer cannot consume from the buffer if it is empty.

Example: Producer-Consumer with Bounded Buffer

import java.util.LinkedList;
import java.util.Queue;

class BoundedBuffer {
    private final Queue buffer = new LinkedList<>();
    private final int capacity;

    public BoundedBuffer(int capacity) {
        this.capacity = capacity;
    }

    // Produce a value
    public synchronized void produce(int value) throws InterruptedException {
        while (buffer.size() == capacity) {
            wait();  // Wait if buffer is full
        }
        buffer.add(value);
        System.out.println("Produced: " + value);
        notifyAll();  // Notify consumers that a new item is available
    }

    // Consume a value
    public synchronized int consume() throws InterruptedException {
        while (buffer.isEmpty()) {
            wait();  // Wait if buffer is empty
        }
        int value = buffer.poll();
        System.out.println("Consumed: " + value);
        notifyAll();  // Notify producers that a slot is available
        return value;
    }
}

public class BoundedBufferExample {
    public static void main(String[] args) {
        BoundedBuffer buffer = new BoundedBuffer(2);  // Buffer with capacity of 2

        // Producer thread
        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) { buffer.produce(i); Thread.sleep(100); // Simulate production delay } } catch (InterruptedException e) { e.printStackTrace(); } }); // Consumer thread Thread consumer = new Thread(() -> {
            try {
                for (int i = 1; i <= 5; i++) {
                    buffer.consume();
                    Thread.sleep(150);  // Simulate consumption delay
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Start producer and consumer
        producer.start();
        consumer.start();
    }
}

Explanation:

The buffer has a capacity of 2.
The producer produces values into the buffer, and the consumer consumes values from the buffer.
If the buffer is full, the producer waits. If the buffer is empty, the consumer waits.

Output:

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

Conclusion

Java provides powerful mechanisms for inter-thread communication through wait(), notify(), and notifyAll(). These methods help threads coordinate their execution when they share resources. Key points to remember:

wait() puts the thread into a waiting state until another thread calls notify() or notifyAll().
notify() wakes up a single waiting thread, while notifyAll() wakes up all waiting threads.
Always use these methods inside a synchronized block to ensure safe communication between threads.

By mastering these concepts, you can build robust and efficient multithreaded applications in Java.

October 10, 2024 0 comment

Advanced

Java Thread Deadlock Tutorial

written by 75ypsaw71

A deadlock in Java occurs when two or more threads are blocked forever, waiting for each other to release the resources they need. Deadlock happens when threads acquire locks in an inconsistent order and attempt to access resources in such a way that they block each other.

In this tutorial, we'll learn what deadlock is, how it can occur in multithreaded Java programs, and how to avoid it.

We’ll also provide several code examples to help you understand the problem and its solutions.

Table of Contents

1. What is Deadlock?

A deadlock occurs in multithreaded applications when two or more threads are waiting indefinitely for a condition that can never be satisfied. Deadlocks arise when the following conditions are met:

Mutual Exclusion: At least two threads require exclusive access to resources.
Hold and Wait: Threads hold resources and wait for additional resources held by other threads.
No Preemption: Resources cannot be forcibly taken away from threads; they must be released voluntarily.
Circular Wait: A circular chain of threads exists where each thread holds a resource that the next thread in the chain needs.
These conditions lead to a situation where all threads involved are stuck, waiting for each other, and none can proceed.

2. Example of Deadlock

Below is an example of a deadlock scenario in Java where two threads (Thread-1 and Thread-2) are waiting for each other to release resources (resource1 and resource2).

Example:

public class DeadlockExample {
    // Resource 1 and Resource 2
    private final Object resource1 = new Object();
    private final Object resource2 = new Object();

    public static void main(String[] args) {
        DeadlockExample deadlock = new DeadlockExample();
        deadlock.startThreads();
    }

    public void startThreads() {
        // Thread 1
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Locked resource 1");

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

                System.out.println("Thread 1: Waiting for resource 2");
                synchronized (resource2) {
                    System.out.println("Thread 1: Locked resource 2");
                }
            }
        });

        // Thread 2
        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Locked resource 2");

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

                System.out.println("Thread 2: Waiting for resource 1");
                synchronized (resource1) {
                    System.out.println("Thread 2: Locked resource 1");
                }
            }
        });

        // Start both threads
        thread1.start();
        thread2.start();
    }
}

Explanation:

Thread 1 locks resource1 and then waits for resource2.
Thread 2 locks resource2 and then waits for resource1.
Neither thread can proceed because both are holding a resource the other needs, resulting in a deadlock.

Output:

Thread 1: Locked resource 1
Thread 2: Locked resource 2
Thread 1: Waiting for resource 2
Thread 2: Waiting for resource 1

At this point, both threads are stuck, and the program will not progress because they are each waiting for the other to release the resource.

3. How to Avoid Deadlock

There are several strategies to avoid deadlock in Java:

Lock Ordering: Always acquire locks in a consistent order.
Lock Timeout: Use timeout mechanisms while trying to acquire a lock.
Avoid Holding Locks While Waiting: Avoid holding multiple locks simultaneously.
Deadlock Detection: Implement a deadlock detection mechanism (complex but effective).

4. Solution: Avoiding Deadlock with Lock Ordering

By ensuring that all threads acquire locks in the same order, you can prevent circular wait conditions that lead to deadlocks.

Example:

Solving Deadlock by Lock Ordering

public class DeadlockSolution {
    // Resource 1 and Resource 2
    private final Object resource1 = new Object();
    private final Object resource2 = new Object();

    public static void main(String[] args) {
        DeadlockSolution solution = new DeadlockSolution();
        solution.startThreads();
    }

    public void startThreads() {
        // Thread 1
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Locked resource 1");

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

                System.out.println("Thread 1: Waiting for resource 2");
                synchronized (resource2) {
                    System.out.println("Thread 1: Locked resource 2");
                }
            }
        });

        // Thread 2 follows the same lock order
        Thread thread2 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 2: Locked resource 1");

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

                System.out.println("Thread 2: Waiting for resource 2");
                synchronized (resource2) {
                    System.out.println("Thread 2: Locked resource 2");
                }
            }
        });

        // Start both threads
        thread1.start();
        thread2.start();
    }
}

Explanation:

Both Thread 1 and Thread 2 now acquire resource1 first and then resource2, ensuring that all threads follow the same locking order.
This eliminates the risk of deadlock, as there is no circular wait condition.

Output:

Thread 1: Locked resource 1
Thread 2: Locked resource 1
Thread 1: Waiting for resource 2
Thread 1: Locked resource 2
Thread 2: Waiting for resource 2
Thread 2: Locked resource 2

In this case, Thread 1 acquires both resources and finishes, followed by Thread 2, avoiding deadlock.

5. Solution: Avoiding Deadlock with tryLock() and Timeout

The ReentrantLock class in Java provides a tryLock() method, which tries to acquire the lock and can fail if the lock is not available. This method also allows specifying a timeout to avoid long waits.

Example:

Solving Deadlock with tryLock()

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

public class TryLockSolution {
    private final Lock lock1 = new ReentrantLock();
    private final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        TryLockSolution solution = new TryLockSolution();
        solution.startThreads();
    }

    public void startThreads() {
        // Thread 1
        Thread thread1 = new Thread(() -> {
            try {
                if (lock1.tryLock()) {
                    System.out.println("Thread 1: Locked lock1");
                    try {
                        Thread.sleep(100);
                        if (lock2.tryLock()) {
                            System.out.println("Thread 1: Locked lock2");
                            lock2.unlock();
                        }
                    } finally {
                        lock1.unlock();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Thread 2
        Thread thread2 = new Thread(() -> {
            try {
                if (lock2.tryLock()) {
                    System.out.println("Thread 2: Locked lock2");
                    try {
                        Thread.sleep(100);
                        if (lock1.tryLock()) {
                            System.out.println("Thread 2: Locked lock1");
                            lock1.unlock();
                        }
                    } finally {
                        lock2.unlock();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Start both threads
        thread1.start();
        thread2.start();
    }
}

Explanation:

The tryLock() method is used to attempt to acquire the locks without waiting indefinitely.
If a lock is not acquired, the thread proceeds without getting blocked forever, preventing deadlock.

Output (may vary):

Thread 1: Locked lock1
Thread 2: Locked lock2

In this case, one thread may fail to acquire both locks, but the deadlock is avoided, and the program can still proceed.

6. Deadlock Detection

While deadlock detection is more complex to implement, you can monitor thread states or use third-party tools to detect deadlocks at runtime. Java provides ThreadMXBean in the java.lang.management package to detect deadlocked threads.

Example:

Deadlock Detection Using ThreadMXBean

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;

public class DeadlockDetection {

    public static void main(String[] args) {
        DeadlockExample deadlock = new DeadlockExample();
        deadlock.startThreads();

        // Detect deadlock
        ThreadMXBean bean = ManagementFactory.getThreadMXBean();
        while (true) {
            long[] threadIds = bean.findDeadlockedThreads();
            if (threadIds != null) {
                System.out.println("Deadlock detected!");
                break;
            }
        }
    }
}

Explanation:

The ThreadMXBean provides a method findDeadlockedThreads() to check if there are any deadlocked threads.
This code continually monitors for deadlocks and prints a message when a deadlock is detected.

Output (if deadlock occurs):

Deadlock detected!

7. Summary of Deadlock Prevention Techniques

Here are a few strategies to prevent deadlocks in Java:

Lock Ordering: Always acquire locks in a fixed order.
TryLock: Use the tryLock() method from ReentrantLock to attempt acquiring locks with a timeout.
Minimize Lock Scope: Hold locks for the shortest time possible to reduce the chance of deadlock.
Avoid Nested Locks: Avoid acquiring multiple locks if possible.
Deadlock Detection: Use tools or implement detection mechanisms like ThreadMXBean to identify deadlocks in the system.

Conclusion

In this tutorial, we explored the concept of thread deadlock in Java, how it can occur, and different strategies for avoiding it. We covered:

What is a deadlock, and how it happens in a multithreaded program.
A simple example of deadlock where two threads wait for each other to release resources.
Techniques to avoid deadlocks using:
Lock ordering to acquire locks in a consistent order.
tryLock() with timeouts to prevent threads from waiting indefinitely.
Using ThreadMXBean for deadlock detection.

By understanding these strategies, you can prevent deadlocks in your Java applications and build more robust, concurrent systems.

October 10, 2024 0 comment

Advanced

Java Thread Priority Tutorial

written by 75ypsaw71

In Java, each thread has a priority that helps the Thread Scheduler decide the order in which threads are executed. Thread priority is an integer value that ranges from 1 to 10, with the following constants defined in the Thread class:

Thread.MIN_PRIORITY = 1 (Lowest priority)
Thread.NORM_PRIORITY = 5 (Default priority)
Thread.MAX_PRIORITY = 10 (Highest priority)

Threads with higher priority are more likely to be executed before threads with lower priority, but thread priority is only a hint to the JVM and actual execution order is platform-dependent. Therefore, thread scheduling behavior might vary across different operating systems.

In this tutorial, we will explore how to set and use thread priorities in Java with several examples.

Table of Contents

1. Understanding Thread Priority

By default, when a thread is created, it inherits the priority of the thread that created it. The priority can be changed using the setPriority() method, and you can retrieve a thread's priority using the getPriority() method.

Syntax for Setting and Getting Thread Priority

// Set thread priority
thread.setPriority(int priority);  // Priority between 1 and 10

// Get thread priority
int priority = thread.getPriority();

2. Creating a Thread with Priority

Here’s a basic example of setting thread priority in Java.

Example:

Setting and Getting Thread Priority

public class ThreadPriorityExample {
    public static void main(String[] args) {
        // Creating a thread with normal priority
        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 Priority: " + Thread.currentThread().getPriority());
        });

        // Creating a thread with maximum priority
        Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 Priority: " + Thread.currentThread().getPriority());
        });

        // Setting priorities
        thread1.setPriority(Thread.NORM_PRIORITY); // 5 (Normal priority)
        thread2.setPriority(Thread.MAX_PRIORITY);  // 10 (Maximum priority)

        // Start both threads
        thread1.start();
        thread2.start();
    }
}

Explanation:

thread1 is set to normal priority (5), and thread2 is set to maximum priority (10).
getPriority() returns the priority of each thread, which is printed to the console.

Output:

Thread 1 Priority: 5
Thread 2 Priority: 10

3. Thread Priority with Multiple Threads

In this example, we create multiple threads with different priorities and observe the execution order.

Example:

Running Threads with Different Priorities

public class MultiThreadPriorityExample {
    public static void main(String[] args) {
        // Creating thread 1 (Low Priority)
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) { System.out.println("Low Priority Thread (1): " + i); } }); // Creating thread 2 (Normal Priority) Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) { System.out.println("Normal Priority Thread (5): " + i); } }); // Creating thread 3 (High Priority) Thread thread3 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("High Priority Thread (10): " + i);
            }
        });

        // Setting thread priorities
        thread1.setPriority(Thread.MIN_PRIORITY);  // 1
        thread2.setPriority(Thread.NORM_PRIORITY); // 5
        thread3.setPriority(Thread.MAX_PRIORITY);  // 10

        // Start all threads
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

Explanation:

Thread 1 has the lowest priority (Thread.MIN_PRIORITY = 1).
Thread 2 has the default priority (Thread.NORM_PRIORITY = 5).
Thread 3 has the highest priority (Thread.MAX_PRIORITY = 10).
The order in which the threads are executed may differ depending on the underlying operating system and JVM implementation.

Sample Output (may vary):

High Priority Thread (10): 1
High Priority Thread (10): 2
High Priority Thread (10): 3
High Priority Thread (10): 4
High Priority Thread (10): 5
Normal Priority Thread (5): 1
Normal Priority Thread (5): 2
Normal Priority Thread (5): 3
Normal Priority Thread (5): 4
Normal Priority Thread (5): 5
Low Priority Thread (1): 1
Low Priority Thread (1): 2
Low Priority Thread (1): 3
Low Priority Thread (1): 4
Low Priority Thread (1): 5

Note: Higher-priority threads (thread3) are more likely to run first, but this is not guaranteed since thread scheduling depends on the JVM and operating system.

4. Effect of Thread Priority in Multithreaded Programs

Thread priorities can influence the thread scheduling, but priorities are platform-dependent and do not guarantee strict control over the thread execution order. In this example, we create more threads and observe how priorities might affect the execution.

Example:

Thread Priority with Multiple Threads Running Simultaneously

public class ComplexThreadPriorityExample {
    public static void main(String[] args) {
        // Creating 5 threads with different priorities
        for (int i = 1; i <= 5; i++) { final int threadNumber = i; Thread thread = new Thread(() -> {
                for (int j = 1; j <= 3; j++) {
                    System.out.println("Thread " + threadNumber + " is running. Iteration: " + j);
                }
            });

            // Set thread priority based on threadNumber
            if (threadNumber == 1) {
                thread.setPriority(Thread.MIN_PRIORITY); // Lowest priority
            } else if (threadNumber == 5) {
                thread.setPriority(Thread.MAX_PRIORITY); // Highest priority
            } else {
                thread.setPriority(Thread.NORM_PRIORITY); // Normal priority
            }

            // Start the thread
            thread.start();
        }
    }
}

Explanation:

We create 5 threads, each with different priorities: thread 1 gets the lowest priority, thread 5 gets the highest priority, and the others get normal priority.
Output can vary based on the platform and JVM, but higher-priority threads are more likely to run first.

Sample Output (may vary):

Thread 5 is running. Iteration: 1
Thread 5 is running. Iteration: 2
Thread 5 is running. Iteration: 3
Thread 2 is running. Iteration: 1
Thread 2 is running. Iteration: 2
Thread 2 is running. Iteration: 3
Thread 3 is running. Iteration: 1
Thread 3 is running. Iteration: 2
Thread 3 is running. Iteration: 3
Thread 4 is running. Iteration: 1
Thread 4 is running. Iteration: 2
Thread 4 is running. Iteration: 3
Thread 1 is running. Iteration: 1
Thread 1 is running. Iteration: 2
Thread 1 is running. Iteration: 3

5. Limitations of Thread Priority

While thread priority can influence the order in which threads are executed, it is important to understand its limitations:

Platform-Dependent: Thread priorities are only hints to the JVM. Different operating systems may handle thread priorities differently, so behavior may vary across platforms.
No Strict Guarantees: Even with different priorities, the execution order of threads is not guaranteed. Other factors, such as the number of available CPUs and system load, can affect thread scheduling.
Too Many High-Priority Threads: If too many threads have the highest priority, it can lead to starvation of lower-priority threads.

Example:

Overloading the Scheduler with High-Priority Threads

public class StarvationExample {
    public static void main(String[] args) {
        // High-priority threads
        for (int i = 1; i <= 3; i++) { Thread highPriorityThread = new Thread(() -> {
                for (int j = 1; j <= 5; j++) { System.out.println(Thread.currentThread().getName() + " (High Priority) is running."); } }); highPriorityThread.setPriority(Thread.MAX_PRIORITY); highPriorityThread.setName("High-Priority Thread " + i); highPriorityThread.start(); } // Low-priority thread Thread lowPriorityThread = new Thread(() -> {
            for (int j = 1; j <= 5; j++) {
                System.out.println(Thread.currentThread().getName() + " (Low Priority) is running.");
            }
        });
        lowPriorityThread.setPriority(Thread.MIN_PRIORITY);
        lowPriorityThread.setName("Low-Priority Thread");
        lowPriorityThread.start();
    }
}

Explanation:

Three high-priority threads are created alongside one low-priority thread.
The low-priority thread might not get enough CPU time due to the dominance of high-priority threads, leading to thread starvation.

Sample Output (may vary):

High-Priority Thread 1 (High Priority) is running.
High-Priority Thread 2 (High Priority) is running.
High-Priority Thread 3 (High Priority) is running.
...
(Low-priority thread may get very little or no CPU time, depending on the system load and JVM)

6. Best Practices with Thread Priority

Use Default Priority When Possible: Unless necessary, stick to the default priority (NORM_PRIORITY = 5) to avoid unexpected behavior across different systems.
Avoid Overusing High Priority: Overloading the scheduler with many high-priority threads can cause lower-priority threads to starve, resulting in poor performance and responsiveness.
Test on Different Platforms: Since thread scheduling behavior can vary between platforms, test your multithreaded application on different operating systems to ensure consistent behavior.
Handle Concurrency Properly: Use proper synchronization mechanisms (such as wait(), notify(), and notifyAll() or Lock objects) instead of relying solely on thread priority to manage execution order.

Conclusion

Thread priority in Java gives you a way to suggest the relative importance of different threads to the JVM's thread scheduler. However, thread priority does not guarantee strict control over thread execution order, and it is heavily dependent on the underlying operating system.

In this tutorial, we covered:

How to set and get thread priority.
How thread priority can influence the order of execution in multithreaded programs.
The limitations of thread priority and how it can lead to issues like thread starvation.
Best practices when using thread priority to ensure reliable and maintainable multithreaded applications.

By understanding thread priority and the underlying system behavior, you can write more efficient and responsive multithreaded applications in Java.

October 9, 2024 0 comment

Advanced

Java Thread Scheduler Tutorial

written by 75ypsaw71

In Java, Thread Scheduler is part of the JVM (Java Virtual Machine) responsible for determining which thread runs at any given time. The Thread Scheduler uses thread priorities and the underlying operating system's scheduling mechanisms to decide how threads are managed and executed.

While Java does not provide direct control over the Thread Scheduler, you can influence how threads behave using thread priorities and other concurrency control mechanisms. It's important to note that the actual scheduling behavior is platform-dependent, meaning different operating systems may handle thread scheduling differently.

In this tutorial, we will explore how Java threads work with the Thread Scheduler, how to use thread priorities, and how to manage thread behavior with code examples.

Table of Contents

1. Introduction to Thread Scheduling

Java provides a preemptive scheduling model where each thread competes for CPU time based on thread priority. The thread scheduler decides which thread runs at any given time, and threads may be:

Running: Currently executing.
Runnable: Ready to run, waiting for CPU time.
Blocked/Waiting: Paused, waiting for a resource or event.
Java threads can be preempted (interrupted by higher-priority threads), or they may yield (voluntarily give up the CPU).

2. Setting Thread Priority

Each thread in Java has a priority value between 1 and 10, where:

Thread.MIN_PRIORITY = 1 (lowest priority)
Thread.NORM_PRIORITY = 5 (default priority)
Thread.MAX_PRIORITY = 10 (highest priority)
Higher-priority threads are more likely to be chosen by the scheduler to run first. However, thread priorities are just hints to the scheduler, and actual behavior can vary based on the operating system.

Example of Setting Thread Priority:

public class ThreadPriorityExample {
    public static void main(String[] args) {
        // Creating two threads with different priorities
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) { System.out.println("Thread 1 (Priority: " + Thread.currentThread().getPriority() + ") - Count: " + i); } }); Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread 2 (Priority: " + Thread.currentThread().getPriority() + ") - Count: " + i);
            }
        });

        // Setting thread priorities
        thread1.setPriority(Thread.MIN_PRIORITY);  // Lowest priority (1)
        thread2.setPriority(Thread.MAX_PRIORITY);  // Highest priority (10)

        // Starting the threads
        thread1.start();
        thread2.start();
    }
}

Explanation:

thread1 is set to the lowest priority using setPriority(Thread.MIN_PRIORITY).
thread2 is set to the highest priority using setPriority(Thread.MAX_PRIORITY).
The output may show that thread2 is more likely to finish before thread1, but this behavior can vary depending on the system.

Output (may vary based on OS and JVM):

Thread 2 (Priority: 10) - Count: 1
Thread 2 (Priority: 10) - Count: 2
Thread 2 (Priority: 10) - Count: 3
Thread 2 (Priority: 10) - Count: 4
Thread 2 (Priority: 10) - Count: 5
Thread 1 (Priority: 1) - Count: 1
Thread 1 (Priority: 1) - Count: 2
Thread 1 (Priority: 1) - Count: 3
Thread 1 (Priority: 1) - Count: 4
Thread 1 (Priority: 1) - Count: 5

3. The yield() Method

The Thread.yield() method is a hint to the scheduler that the current thread is willing to yield (pause) and allow other threads to execute. This is useful for creating more cooperative multithreading but does not guarantee any specific behavior.

Example of Using yield():

public class YieldExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) { System.out.println("Thread 1 (yielding)"); Thread.yield(); // Yielding to allow other threads to execute } }); Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread 2 (running)");
            }
        });

        // Starting both threads
        thread1.start();
        thread2.start();
    }
}

Explanation:

Thread.yield() allows thread1 to suggest that other threads (e.g., thread2) run.
thread1 will give up the CPU, but there is no guarantee that thread2 will immediately run—it depends on the scheduler.

Output (may vary):

Thread 1 (yielding)
Thread 2 (running)
Thread 1 (yielding)
Thread 2 (running)
Thread 2 (running)
Thread 2 (running)
Thread 2 (running)
Thread 1 (yielding)

4. The sleep() Method

The Thread.sleep() method pauses the execution of the current thread for a specified period (in milliseconds). During this time, the thread is in a sleeping state and does not consume CPU resources.

Example of Using sleep():

public class SleepExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Thread is running: Count " + i);
                try {
                    Thread.sleep(1000);  // Sleep for 1 second
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // Starting the thread
        thread.start();
    }
}

Explanation:

The Thread.sleep(1000) pauses the thread for 1 second between iterations.
The InterruptedException must be handled in case the thread is interrupted while sleeping.

Output (1-second delay between each print):

Thread is running: Count 1
Thread is running: Count 2
Thread is running: Count 3
Thread is running: Count 4
Thread is running: Count 5

5. The join() Method

The join() method allows one thread to wait for another thread to complete before continuing its execution. This is useful when you need to ensure that a certain thread finishes before others.

Example of Using join():

public class JoinExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 3; i++) { System.out.println("Thread 1 running..."); try { Thread.sleep(500); // Sleep for 0.5 second } catch (InterruptedException e) { e.printStackTrace(); } } }); Thread thread2 = new Thread(() -> {
            System.out.println("Thread 2 waiting for thread 1 to finish...");
            try {
                thread1.join();  // Wait for thread1 to finish
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 started after thread 1.");
        });

        // Start thread1 and thread2
        thread1.start();
        thread2.start();
    }
}

Explanation:

thread2 will wait for thread1 to finish before it proceeds, thanks to the join() method.

Output:

Thread 2 waiting for thread 1 to finish...
Thread 1 running...
Thread 1 running...
Thread 1 running...
Thread 2 started after thread 1.

6. Thread State

Java threads have different states, and these states represent the lifecycle of a thread:

NEW: A thread that has not yet started.
RUNNABLE: A thread that is ready to run or currently running.
BLOCKED: A thread that is blocked and waiting to acquire a lock.
WAITING: A thread that is waiting indefinitely for another thread to perform an action.
TIMED_WAITING: A thread that is waiting for a specified time.
TERMINATED: A thread that has finished execution.

Example of Checking Thread State:

public class ThreadStateExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running");
        });

        // Checking thread state before starting
        System.out.println("Thread state: " + thread.getState());  // NEW

        // Start the thread
        thread.start();

        // Checking thread state after starting
        System.out.println("Thread state: " + thread.getState());  // RUNNABLE (may vary)

        // Sleep to ensure the thread finishes
        try {
            Thread.sleep(100);  // Wait for the thread to finish
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Checking thread state after execution
        System.out.println("Thread state: " + thread.getState());  // TERMINATED
    }
}

Explanation:

You can check the state of a thread using the getState() method.

Output (may vary depending on thread execution):

Thread state: NEW
Thread state: RUNNABLE
Thread is running
Thread state: TERMINATED

7. Thread Yielding vs. Sleeping

While both yield() and sleep() affect the thread's execution, there are key differences:

yield(): Suggests the thread scheduler give other threads a chance to run, but the current thread may continue running if no other thread is ready.
sleep(): Pauses the current thread for a specified time and guarantees that the thread will not run during that period.

8. Thread Scheduler Behavior (Platform Dependency)

The Java Thread Scheduler relies on the underlying operating system's scheduling algorithm, which can differ between platforms (e.g., Windows, Linux, macOS). Therefore, thread priority and other scheduling behaviors can vary.

Windows: Typically uses a time-slicing mechanism where each thread is given a time slot (quantum) to execute.
Linux: Uses fair scheduling and prioritizes based on various factors, including thread priorities and resource needs.
While Java provides APIs to influence thread behavior, the exact scheduling is not guaranteed and depends on the JVM and OS.

Conclusion

Java's Thread Scheduler determines the execution order of threads in a concurrent environment, but it offers limited direct control over how threads are scheduled. Key concepts include:

Thread Priority: You can suggest the relative importance of a thread using priorities, but behavior is platform-dependent.
yield(): A way to suggest that the current thread allows others to run.
sleep(): Pauses a thread for a specific time period, relinquishing the CPU.
join(): Ensures one thread waits for another thread to finish before continuing.
Thread States: Understanding the lifecycle of a thread is critical to managing concurrency.

By leveraging these tools, you can effectively manage thread execution and influence the behavior of the JVM's thread scheduler, although the final decisions are made by the underlying operating system.

October 9, 2024 0 comment

Newer Posts

Older Posts