Reactive Programming with Java Project Loom

The article argues that reactive programming and Project Loom are complementary tools for building concurrent applications in Java, rather than competing approaches.

It highlights the strengths of each:

◉ Reactive programming’s focus on asynchronous operations and data streams.

◉ Project Loom’s ability to simplify concurrency with lightweight virtual threads.

The key takeaway is that combining them can lead to highly responsive and scalable applications.

1. Reactive Programming Deep Dive

Reactive programming is a paradigm for building applications that deal with data streams and asynchronous operations efficiently. It offers a different approach to concurrency compared to traditional thread-based programming. Here’s a breakdown of its core concepts, benefits, and challenges:

The Reactive Principles: Foundations of Responsiveness

The Reactive Manifesto outlines four key principles that guide the design of reactive systems:

1. Responsive: A reactive system prioritizes providing timely responses to users, even under heavy load. This means minimizing blocking operations and handling events efficiently.

2. Resilient: Reactive systems are designed to gracefully handle failures and unexpected events. They can recover from errors and continue functioning without significant downtime.

3. Elastic: Reactive systems can scale up or down their resources based on demand. This allows them to adapt to changes in workload without compromising performance.

4. Message-Driven: Communication within a reactive system happens through asynchronous messages. This promotes loose coupling between components and simplifies handling concurrency.

Subheading: Non-Blocking I/O – The Engine of Responsiveness:

Reactive programming heavily relies on non-blocking I/O operations. This means an operation, such as reading data from a network, doesn’t block the execution of the program. The program can continue processing other tasks while waiting for the I/O to complete. This approach significantly improves responsiveness by preventing the application from getting stuck on slow operations.

Subheading: Backpressure – Managing the Flow of Data:

In reactive systems, data flows as streams of events. Backpressure is a technique used to manage the rate at which data is processed. It allows components to signal when they are overloaded and need to slow down the stream of incoming data. This prevents overwhelming downstream components and ensures smooth processing throughout the system.

Benefits of Reactive Programming: Building Scalable and Responsive Applications

Reactive programming offers several advantages for building modern applications:

◉ Improved responsiveness: Non-blocking I/O and efficient event handling lead to applications that feel faster and more responsive under load. Users experience smooth interactions even when the system is busy.

◉ Enhanced scalability: Reactive systems can easily scale to handle increased load by adding more resources. This allows applications to grow without significant performance degradation.

◉ Resilience and fault tolerance: Reactive principles promote systems that can recover from failures gracefully. Asynchronous communication and message-driven architecture help isolate errors and prevent them from cascading through the entire system.

◉ Simpler handling of concurrency: Reactive programming avoids complex thread management techniques often associated with traditional concurrent programming. This can simplify development and reduce the risk of concurrency bugs.

Challenges of Reactive Programming: A Different Mindset

While powerful, reactive programming comes with its own set of challenges:

◉ Increased complexity: Designing and developing reactive systems can have a steeper learning curve compared to traditional approaches. Developers need to understand concepts like streams, operators, and schedulers.

◉ Mental model shift: Reactive programming requires a different way of thinking about program flow compared to imperative programming. Developers need to adapt to an event-driven and asynchronous perspective.

◉ Debugging challenges: Debugging reactive applications can be more complex due to the asynchronous nature of operations. Tools and techniques specifically designed for reactive systems are essential.

2. Project Loom in Detail

Imagine a world where you can write highly concurrent applications without worrying about complex thread management. That’s the promise of Project Loom, a recent addition to the Java world. Let’s delve into virtual threads, their advantages, and how Loom simplifies concurrency.

Virtual Threads: A Lighter Take on Concurrency

Traditional threads in Java are heavyweight entities managed by the operating system. They require significant resources, and creating too many can overwhelm the system. Project Loom introduces virtual threads, a lightweight alternative.

Think of virtual threads as actors in a play. Each actor has a script (the code to execute), but they don’t need a dedicated stage (operating system thread) all the time. Project Loom manages a pool of real threads, and virtual threads share this pool efficiently.

Here’s a simplified code snippet to illustrate the difference:

// Traditional Thread

Thread thread = new Thread(() -> {

  // Do some work

});

thread.start();

// Project Loom Virtual Thread (code preview)

var virtualThread = Loom.newVirtualThread(() -> {

  // Do some work

});

virtualThread.start();

In the traditional approach, we create a new Thread object, which requires system resources. Project Loom’s Loom.newVirtualThread creates a virtual thread that leverages the shared pool, reducing resource overhead.

Advantages of Virtual Threads: More Power, Less Complexity

Virtual threads offer several advantages:

◉ Reduced Memory Footprint: They require less memory compared to traditional threads, allowing you to create a much larger pool of concurrent tasks.

◉ Faster Startup and Context Switching: Virtual threads are quicker to create and switch between, improving overall application performance.

◉ Simplified Concurrency Management: No more juggling thread pools and complex synchronization mechanisms. Project Loom handles the heavy lifting, making concurrent programming more accessible.

Project Loom: Not a Silver Bullet (But Pretty Close)

While Project Loom is a game-changer, there are a few things to keep in mind:

◉ Preview Feature: As of now, Project Loom is a preview feature in Java 19. Its API and behavior might evolve in future releases.

◉ Blocking Operations Still Costly: While virtual threads improve efficiency, blocking operations like waiting for network requests can still impact performance.

◉ Learning Curve: Understanding virtual threads and their interactions with traditional threads requires some additional learning for developers.

Overall, Project Loom significantly simplifies concurrent programming in Java. It allows developers to focus on the core logic of their application without getting bogged down in thread management complexities.

3. Reactive Programming and Project Loom: A Powerful Duo

Reactive programming and Project Loom are two innovative advancements in the Java world, each tackling concurrency from unique angles. While they might seem like rivals, they actually work together beautifully to create highly responsive and scalable applications. Here’s a breakdown of how they synergize:

Virtual Threads Fuel Reactive Streams

Reactive programming excels at processing data streams asynchronously. This involves operations like network requests and database calls, which can be slow. Here’s where Project Loom shines:

◉ Efficient Asynchronous Task Execution: Traditional threads are heavyweight and limited in number. Project Loom introduces virtual threads, lightweight alternatives that require less memory. This allows for a much larger pool of concurrent tasks.

In a reactive pipeline, virtual threads become the workhorses. They efficiently execute asynchronous operations within the pipeline, like fetching data from a database, without blocking the main program flow. This significantly improves the application’s responsiveness, even under heavy load.

Imagine a web server handling multiple user requests concurrently. Traditional threads would be like having a limited number of servers struggling to keep up. Virtual threads act as additional servers, efficiently processing each request (fetching data) without slowing down the overall response time.

◉ Scalability for High-Volume Data: Reactive applications often deal with large amounts of data. The vast pool of virtual threads in Project Loom allows for massive concurrency. This enables the system to scale up and handle increased data flow efficiently.

Consider a social media platform processing a constant stream of user posts. Traditional threads would struggle with the volume, leading to delays and sluggish performance. Virtual threads create a scalable infrastructure, allowing the platform to handle peak activity without compromising responsiveness.

Reactive Principles Guide Efficient Loom Usage

The core principles of reactive programming can be leveraged to further optimize concurrency management with Project Loom:

◉ Non-Blocking I/O and Virtual Threads: Reactive programming emphasizes non-blocking I/O operations, perfectly aligning with Project Loom’s virtual threads. This creates a system where tasks within a reactive pipeline are executed concurrently without blocking each other. This maximizes resource utilization and overall performance.

◉ Backpressure and Virtual Thread Pool Management: Backpressure in reactive programming ensures that downstream components aren’t overwhelmed with data. This can be used in conjunction with Project Loom to dynamically adjust the number of virtual threads in the pool based on the data flow. This prevents overloading the system and ensures smooth processing throughout the pipeline.

Think of a data processing pipeline with multiple stages. Backpressure acts as a signal that a particular stage is nearing capacity. By monitoring this signal, Project Loom can dynamically adjust the number of virtual threads allocated to that stage, preventing bottlenecks and ensuring efficient data processing.

4. Benefits of the Combination

Reactive programming and Project Loom are two advancements in Java that, when combined, offer significant advantages for building concurrent applications. Here’s a breakdown of the key benefits this combination brings:

Advantage	Description
Increased Responsiveness	Traditional threaded applications can become sluggish under heavy load, especially when dealing with slow I/O operations. Reactive programming’s focus on non-blocking I/O and asynchronous processing ensures a smoother user experience even during peak usage. Project Loom further enhances responsiveness by providing a large pool of lightweight virtual threads for efficient execution of these asynchronous tasks. This translates to faster response times and a more fluid user experience.
Enhanced Scalability	As application demands grow, traditional thread-based systems can struggle to scale effectively. Reactive programming promotes building applications with elastic resources that can adapt to changing workloads. Project Loom’s virtual threads are lightweight and require less memory compared to traditional threads. This allows for creating a much larger pool of concurrent tasks, enabling the system to scale up and handle increased data flow efficiently. This combined approach ensures applications can handle significant growth without compromising performance.
Simpler Development and Maintenance of Concurrent Code	Traditional concurrency management in Java can involve complex thread manipulation techniques, leading to error-prone code. Reactive programming offers a paradigm shift towards data streams and asynchronous operations, simplifying the overall development process. Project Loom further reduces complexity by eliminating the need for intricate thread pool management. Developers can focus on the core logic of their application without getting bogged down in low-level concurrency details. This combination makes building and maintaining concurrent applications easier and less error-prone.

Source: javacodegeeks.com

Continue reading

Oracle Java Security: Protecting Your Code from the Latest Threats

In the ever-evolving landscape of software development, Oracle Java remains a cornerstone for developers around the world. As one of the most widely used programming languages, it is imperative to ensure that Java applications are secure against the latest threats. This article delves into the comprehensive strategies and best practices to safeguard your Java code, ensuring robust protection against potential vulnerabilities.

Understanding the Importance of Java Security

Java's popularity makes it a prime target for cyber threats. Understanding the inherent security challenges within Java applications is the first step toward mitigating risks. These challenges often stem from:

• Platform Independence: Java's ability to run on any device with the Java Virtual Machine (JVM) makes it a versatile tool but also opens it to various platform-specific attacks.
• Legacy Systems: Many organizations run critical operations on legacy Java systems, which might not have the latest security updates.
• Complex Dependencies: Java applications often rely on a myriad of third-party libraries and frameworks, increasing the risk of vulnerabilities.

Common Java Security Threats

To effectively protect your Java applications, it is crucial to be aware of common security threats:

1. Injection Attacks

Injection flaws, such as SQL injection, occur when untrusted data is sent to an interpreter as part of a command or query. This can lead to unauthorized data access and manipulation.

2. Cross-Site Scripting (XSS)

XSS vulnerabilities occur when an application includes untrusted data on a web page without proper validation or escaping, allowing attackers to execute scripts in the user's browser.

3. Insecure Deserialization

Insecure deserialization can lead to remote code execution, denial of service (DoS) attacks, and other malicious activities. This occurs when untrusted data is used to abuse the logic of an application.

4. Weak Authentication and Session Management

Improper implementation of authentication mechanisms can lead to unauthorized access, while poor session management can expose user sessions to hijacking.

Best Practices for Securing Java Applications

1. Keep Java Updated

Regularly update your Java Development Kit (JDK) and Java Runtime Environment (JRE) to incorporate the latest security patches. Oracle frequently releases updates that address newly discovered vulnerabilities.

2. Use Secure Coding Practices

Adopting secure coding standards can significantly reduce the risk of vulnerabilities. Key practices include:

• Input Validation: Always validate and sanitize user inputs to prevent injection attacks.
• Output Encoding: Ensure that data is correctly encoded before rendering it to the client to prevent XSS attacks.
• Least Privilege Principle: Grant the minimum level of access necessary to perform functions, reducing the potential impact of a security breach.

3. Implement Strong Authentication and Authorization

Use robust authentication methods, such as multi-factor authentication (MFA), and implement strict access controls to ensure that only authorized users can access sensitive information.

4. Secure Data Storage

Encrypt sensitive data both at rest and in transit. Use strong encryption algorithms and manage encryption keys securely.

5. Regular Security Audits

Conduct regular security assessments and code reviews to identify and remediate vulnerabilities. Use static analysis tools to scan your codebase for potential security issues.

Advanced Java Security Techniques

1. Use Security Frameworks and Libraries

Leverage established security frameworks and libraries to enhance the security of your Java applications. Some of the widely used security libraries include:

• OWASP ESAPI: The OWASP Enterprise Security API (ESAPI) provides a robust set of tools for developing secure applications.
• Spring Security: A powerful and customizable authentication and access control framework for Java applications.

2. Container Security

If your Java applications are containerized, ensure that your container environment is secure. This includes:

• Using Official Images: Always use official and trusted images for your containers.
• Regular Updates: Keep your container runtime and orchestrator (e.g., Docker, Kubernetes) updated.
• Network Policies: Implement strict network policies to control traffic between containers.

3. Secure API Development

With the rise of microservices and APIs, securing your APIs is critical. Follow these best practices for secure API development:

• Authentication and Authorization: Use OAuth 2.0 and JWT for secure authentication and authorization.
• Input Validation: Validate all inputs to your APIs to prevent injection attacks.
• Rate Limiting: Implement rate limiting to prevent abuse and DoS attacks.

4. Monitor and Respond to Threats

Implement robust monitoring and incident response mechanisms to detect and respond to security incidents promptly. Use tools like:

• SIEM: Security Information and Event Management (SIEM) systems help in real-time analysis of security alerts.
• IDS/IPS: Intrusion Detection Systems (IDS) and Intrusion Prevention Systems (IPS) can detect and prevent malicious activities.

Conclusion

Securing your Java applications is a continuous process that requires vigilance and proactive measures. By understanding common threats and implementing best practices, you can significantly enhance the security of your Java code. Regular updates, secure coding practices, strong authentication mechanisms, and advanced security techniques are essential components of a robust security strategy.

Continue reading

Check if a Number Is Power of 2 in Java

In this article, we will explore different approaches to check if a given number is a power of 2 in Java. We will cover the following methods:

• Loop Division
• Using Bitwise & Operations
• Counting Set Bits
• Using Integer.highestOneBit()
• Using Logarithm

1. Loop Division

This approach involves continuously dividing the number by 2 and checking if the remainder is ever not zero.

public class PowerOf2 {

    public static boolean isPowerOfTwo(int n) {

        if (n <= 0) {

            return false;

        }

        while (n % 2 == 0) {

            n /= 2;

        }

        return n == 1;

    }

 

    public static void main(String[] args) {

        System.out.println(isPowerOfTwo(16)); // true

        System.out.println(isPowerOfTwo(18)); // false

    }

}

In the above code:

• We check if the number is less than or equal to zero. If it is, we return false.
• We repeatedly divide the number by 2 as long as it is even.
• Finally, we check if the resulting number is 1.

2. Using Bitwise & Operations

This method utilizes the property that powers of 2 have exactly one bit set in their binary representation.

public class PowerOf2 {

    public static boolean isPowerOfTwo(int n) {

        return n > 0 && (n & (n - 1)) == 0;

    }

 

    public static void main(String[] args) {

        System.out.println(isPowerOfTwo(16)); // true

        System.out.println(isPowerOfTwo(18)); // false

    }

}

In the above code:

◉ We check if the number is greater than zero.

◉ We use the bitwise AND operation to check if the number has only one bit set.

3. Counting Set Bits

This approach counts the number of set bits (1s) in the binary representation of the number.

public class PowerOf2 {

    public static boolean isPowerOfTwo(int n) {

        if (n > 0) {

            count += (n & 1);

            n >>= 1;

        }

        return count == 1;

    }

 

    public static void main(String[] args) {

        System.out.println(isPowerOfTwo(16)); // true

        System.out.println(isPowerOfTwo(18)); // false

    }

}

In the above code:

• We check if the number is less than or equal to zero.
• We count the number of set bits by checking the least significant bit and right-shifting the number.
• We return true if the count of set bits is 1.

4. Using Integer.highestOneBit()

This method uses the Integer.highestOneBit() function to check if the number is a power of 2.

public class PowerOf2 {

    public static boolean isPowerOfTwo(int n) {

        return n > 0 && Integer.highestOneBit(n) == n;

    }

 

    public static void main(String[] args) {

        System.out.println(isPowerOfTwo(16)); // true

        System.out.println(isPowerOfTwo(18)); // false

    }

}

In the above code:

• We check if the number is greater than zero.
• We use the Integer.highestOneBit() method to get the highest bit of the number.
• We check if this highest one-bit is equal to the number itself.

5. Using Logarithm

This approach uses the mathematical property that if a number is a power of 2, its logarithm base 2 should be an integer.

public class PowerOf2 {

    public static boolean isPowerOfTwo(int n) {

        if (n <= 0) {

            return false;

        }

        double log2 = Math.log(n) / Math.log(2);

        return log2 == Math.floor(log2);

    }

 

    public static void main(String[] args) {

        System.out.println(isPowerOfTwo(16)); // true

        System.out.println(isPowerOfTwo(18)); // false

    }

}

In the above code:

• We check if the number is less than or equal to zero.
• We calculate the logarithm base 2 of the number.
• We check if the result is an integer.

6. Summary

Method	Advantages	Disadvantages
Loop Division	Simple to understand and implement. Directly checks divisibility by 2.	Less efficient for large numbers due to multiple divisions.
Using Bitwise & Operations	Very efficient with constant time complexity O(1). Utilizes fast bitwise operations.	Requires understanding of bitwise operations.
Counting Set Bits	Conceptually simple and easy to understand.	Less efficient due to the need to count all set bits. Time complexity is O(log n).
Using Integer.highestOneBit()	Efficient and uses a single built-in method. Constant time complexity O(1).	5Depends on an understanding of the Integer.highestOneBit() method.
Using Logarithm	3Uses mathematical properties and is easy to understand.	Less efficient due to the use of floating-point operations. Potential issues with floating-point precision.

Source: javacodegeeks.com

Continue reading

Using Java 8 Optionals: Perform Action Only If All Are Present

Java’s Optional class provides a container object which may or may not contain a non-null value. This is useful for avoiding null checks and preventing NullPointerException. Sometimes, we may need to perform an action only if multiple Optional objects contain values. This article will guide us through various ways to achieve this.

1. Example: Combining User Data

For demonstration purposes, Let’s consider a use case where we need to combine data from different sources to create a full user profile. We have three Optional objects: Optional<String> firstName, Optional<String> lastName, and Optional<String> email. We want to perform an action (e.g., create a user profile) only if all of these Optional objects are present.

2. Using isPresent()

One straightforward way is to use isPresent to check each Optional. Here is an example:

import java.util.Optional;

 

public class IsPresentOptionalExample {

 

    public static void main(String[] args) {

        Optional<String> firstName = Optional.of("Alice");

        Optional<String> lastName = Optional.of("Doe");

        Optional<String> email = Optional.of("alice.doe@jcg.com");

 

        if (firstName.isPresent() && lastName.isPresent() && email.isPresent()) {

            String userProfile = createUserProfile(firstName.get(), lastName.get(), email.get());

            System.out.println(userProfile);

        } else {

            System.out.println("One or more required fields are missing");

        }

    }

 

    private static String createUserProfile(String firstName, String lastName, String email) {

        return "User Profile: " + firstName + " " + lastName + ", Email: " + email;

    }

}

In this example, we check if firstName, lastName, and email are all present. If they are, we create a user profile by calling createUserProfile. Otherwise, we print a message indicating that one or more required fields are missing. This ensures that the action (creating a user profile) is performed only when all necessary data is available.

Output from running the above code is:

User Profile: Alice Doe, Email: alice.doe@jcg.com

3. A Functional Approach with flatMap() and map()

The flatMap method can be used to chain Optional objects in a more functional style. Let’s extend the user profile example to use flatMap for chaining:

public class FlatMapChainingExample {

 

    public static void main(String[] args) {

         

        Optional<String> firstName = Optional.of("Alice");

        Optional<String> lastName = Optional.of("Doe");

        Optional<String> email = Optional.of("alice.doe@jcg.com");

 

        firstName.flatMap(fn -> lastName.flatMap(ln -> email.map(em -> createUserProfile(fn, ln, em))))

                 .ifPresentOrElse(

                     System.out::println,

                     () -> System.out.println("One or more required fields are missing")

                 );

    }

 

    private static String createUserProfile(String firstName, String lastName, String email) {

        return "User Profile: " + firstName + " " + lastName + ", Email: " + email;

    }

}

In this example, flatMap is used to chain the Optional objects. If all Optional objects contain values, createUserProfile is called. If any Optional is empty, a message is printed indicating that the required fields are missing.

4. Using Optional with Streams

Java Streams can be combined with Optional to process sequences of elements. This approach is useful when dealing with a collection of Optional objects. Here’s an example of how to use Streams with Optional:

import java.util.Optional;

import java.util.stream.Stream;

 

public class OptionalStreamExample {

 

    public static void main(String[] args) {

        Optional<String> firstName = Optional.of("Alice");

        Optional<String> lastName = Optional.of("Doe");

        Optional<String> email = Optional.of("alice.doe@jcg.com");

 

        boolean allPresent = Stream.of(firstName, lastName, email)

                                   .allMatch(Optional::isPresent);

 

        if (allPresent) {

            String userProfile = createUserProfile(

                firstName.get(),

                lastName.get(),

                email.get()

            );

            System.out.println(userProfile);

        } else {

            System.out.println("One or more required fields are missing");

        }

    }

 

    private static String createUserProfile(String firstName, String lastName, String email) {

        return "User Profile: " + firstName + " " + lastName + ", Email: " + email;

    }

}

In this example, we use allMatch to check if all Optional objects are present. If all are present, we retrieve the values using get() and create the user profile. If any Optional is empty, we print a message indicating that the required fields are missing.

Output:

User Profile: Alice Doe, Email: alice.doe@jcg.com

5. Conclusion

In this article, we explored various methods to perform actions in Java only when all Optional objects are available. Starting with the basic isPresent checks, we moved on to more functional approaches using flatMap for chaining and integrating Optional with Streams. We also demonstrated a practical use case involving user data to illustrate these concepts.

Source: javacodegeeks.com

Continue reading

Unit Testing of ExecutorService in Java With No Thread sleep

Unit testing concurrent code, especially code utilizing ExecutorService, presents unique challenges due to its asynchronous nature. Traditional approaches often involve using Thread.sleep() to wait for tasks to be completed, but this method is unreliable and can lead to flaky tests. In this article, we’ll explore alternative strategies to unit test ExecutorService without relying on Thread sleep method. This ensures reliable tests that do not depend on arbitrary sleep durations.

1. Understanding ExecutorService

ExecutorService is a framework in Java for executing tasks asynchronously. It manages a pool of threads and allows you to submit tasks for concurrent execution. Testing code that uses ExecutorService typically involves verifying that tasks are executed correctly and that the service behaves as expected under various conditions.

1.1 Challenges with Thread.sleep()

Using Thread.sleep() in tests introduces several issues:

• Non-deterministic Tests: Timing-based tests can be unpredictable and may fail randomly due to variations in thread scheduling and execution speed.
• Slow Tests: Sleeping for a fixed duration can make tests unnecessarily slow, especially if tasks complete quickly or if longer delays are required to ensure completion.

2. Alternative Approaches to Unit Testing ExecutorService

To write reliable tests for ExecutorService without Thread.sleep(), consider the following approaches. First, we create a MyRunnable class that implements the Runnable interface and performs a long-running calculation (In this article, we are calculating the sum of a large range of numbers).

MyRunnable.java

public class MyRunnable implements Runnable {

 

    private final long start;

    private final long end;

    private long result;

 

    public MyRunnable(long start, long end) {

        this.start = start;

        this.end = end;

    }

 

    @Override

    public void run() {

        result = 0;

        for (long i = start; i <= end; i++) {

            result += i;

        }

        System.out.println("Calculation complete. Result: " + result);

    }

 

    public long getResult() {

        return result;

    }

}

2.1 Use Future to Get the Result

To get the result of the task and ensure completion, we can use Future.

FutureExampleTest.java

public class FutureExampleTest {

     

    @Test

    public void testFutureWithLongRunningCalculation() throws Exception {

         

        ExecutorService executor = Executors.newSingleThreadExecutor();

 

        // Create an instance of MyRunnable with a long-running calculation

        MyRunnable task = new MyRunnable(1, 1000000000L);

 

        // Submit the task to the executor and get a Future

        Future<?> future = executor.submit(task);

 

        // Wait for the task to complete and get the result

        future.get(); // Blocks until the task completes

 

        // Verify the result

        long expected = (1000000000L * (1000000000L + 1)) / 2;

        assertEquals(expected, task.getResult());

 

        // Shutdown the executor

        executor.shutdown();

    }

     

}

In this example, we submit the MyRunnable task to the executor and get a Future object. The future.get() method blocks until the task is completed, ensuring we can retrieve the result after completion.

2.2 Use CountDownLatch for Synchronization

To ensure the parent thread waits for the task to complete without using Thread.sleep(), we can use CountDownLatch.

ExecutorServiceExampleTest.java

public class ExecutorServiceExampleTest {

     

    @Test

    public void testExecutorServiceWithLongRunningCalculation() throws InterruptedException {

         

        ExecutorService executor = Executors.newSingleThreadExecutor();

        CountDownLatch latch = new CountDownLatch(1);

 

        // Create a runnable with a long-running calculation

        MyRunnable task = new MyRunnable(1, 1000000000L) {

            @Override

            public void run() {

                super.run();

                latch.countDown();

            }

        };

 

        // Submit the task to the executor

        executor.submit(task);

 

        // Wait for the task to complete

        assertTrue(latch.await(2, TimeUnit.MINUTES));

 

        // Verify the result

        long expected = (1000000000L * (1000000000L + 1)) / 2;

        assertEquals(expected, task.getResult());

 

        // Shutdown the executor

        executor.shutdown();

    }

     

}

This approach uses a CountDownLatch to synchronize the completion of the task. First, we create a CountDownLatch with a count of 1 and define an anonymous subclass of MyRunnable that counts down the latch when the task completes.

Next, we submit this task to the executor and use latch.await() to wait for the task to complete, verifying with assertTrue that the task finishes within the specified timeout. After the task is completed, we verify the result using assertEquals. Finally, we shut down the executor.

2.3 Use Shutdown and Await Termination

To ensure the executor shuts down gracefully after the tasks complete, use shutdown and awaitTermination.

ShutDownExampleTest.java

public class ShutDownExampleTest {

     

    @Test

    public void testShutdownWithLongRunningCalculation() throws InterruptedException {

         

        ExecutorService executor = Executors.newSingleThreadExecutor();

 

        // Create an instance of MyRunnable with a long-running calculation

        MyRunnable task = new MyRunnable(1, 1000000000L);

 

        // Submit the task to the executor

        executor.submit(task);

 

        // Shutdown the executor

        executor.shutdown();

 

        // Wait for existing tasks to complete

        assertTrue(executor.awaitTermination(2, TimeUnit.MINUTES));

 

        // Verify the result

        long expected = (1000000000L * (1000000000L + 1)) / 2;

        assertEquals(expected, task.getResult());

    }    

}

In this approach, we ensure the executor shuts down gracefully by calling shutdown() and then awaitTermination() to wait for existing tasks to complete. If tasks do not complete within the specified timeout, we call shutdownNow() to cancel currently executing tasks and wait again.

3. Conclusion

Unit testing concurrent code with ExecutorService requires careful synchronization to ensure tests are reliable and deterministic. Avoiding Thread.sleep() is essential to prevent flaky tests and improve test execution speed. In this article, we used synchronization aids like CountDownLatch, Future, and shutdown with awaitTermination() to handle concurrency effectively in our tests. These approaches provide more reliable alternatives to Thread.sleep() for unit testing ExecutorService-based code in Java.

Source: javacodegeeks.com

Continue reading

Finding a Key’s Index in Java LinkedHashMap

The Java LinkedHashMap class combines a hash table and linked list to maintain predictable iteration order, unlike HashMap. However, LinkedHashMap does not provide a direct method to get the position (index) of a key-value pair. This article explores methods to retrieve the index of a key-value pair in a LinkedHashMap.

1. Using Iteration

One straightforward method is to iterate through the entrySet of the LinkedHashMap, comparing each key with the target key and returning the index when a match is found.

LinkedHashMapIterationApproach.java

public class LinkedHashMapIteration {

 

    public static void main(String[] args) {

         

        // Create a LinkedHashMap with Integer keys and String values

        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();

        linkedHashMap.put(101, "Alice");

        linkedHashMap.put(202, "Bob");

        linkedHashMap.put(303, "Charlie");

        linkedHashMap.put(404, "David");

 

        // Key to find position for

        Integer key = 303;

         

        // Find the position of the key using iteration approach

        int position = getPositionOfKey(linkedHashMap, key);

         

        // Output the result

        System.out.println("LinkedHashMap: " + linkedHashMap);

        System.out.println("Finding position of key: " + key);

        System.out.println("Position: " + position);

        //System.out.println("The position of the key \"" + key + "\" is: " + position);

    }

 

    public static <K, V> int getPositionOfKey(LinkedHashMap<K, V> map, K key) {

        int index = 0;

        for (Map.Entry<K, V> entry : map.entrySet()) {

            if (entry.getKey().equals(key)) {

                return index;

            }

            index++;

        }

        return -1; // Key not found

    }

}

Output:

LinkedHashMap: {101=Alice, 202=Bob, 303=Charlie, 404=David}

Finding position of key: 303

Position: 2

In this example, we create a LinkedHashMap<Integer, String> and populate it with key-value pairs. Next, we specify key = 303 to demonstrate finding the position of the key 303. The getPositionOfKey method iterates through the entrySet() of the LinkedHashMap and compares each key with key. Upon finding a match (key = 303), it returns the position (index) 2 since indexing starts from 0.

2. Using Key Set Conversion

Using this approach, we convert the key set to a list and then find the index of the key.

LinkedHashMapKeySetConversion.java

public class LinkedHashMapKeySetConversion {

 

    public static void main(String[] args) {

        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();

        linkedHashMap.put("January", 1);

        linkedHashMap.put("February", 2);

        linkedHashMap.put("March", 3);

        linkedHashMap.put("April", 4);

 

        String key = "January";

        int position = getPositionOfKey(linkedHashMap, key);

        System.out.println("The position of the key \"" + key + "\" is: " + position);

    }

 

    public static <K, V> int getPositionOfKey(LinkedHashMap<K, V> map, K key) {

        List<K> keyList = new ArrayList<>(map.keySet());

        return keyList.indexOf(key);

    }

}

Here, the keySet of the LinkedHashMap is converted to an ArrayList. The indexOf method of ArrayList is then used to find the index of the key.

Output:

The position of the key "January" is: 0

3. Using Stream API (Java 8+)

With Java 8 and higher, the Stream API offers a straightforward way to solve this issue using functional programming principles.

LinkedHashMapStreamApiApproach.java

public class LinkedHashMapStreamApiApproach {

 

    public static int findKeyPosition(LinkedHashMap<String, Integer> map, String key) {

        int position = 0;

        Optional<String> foundKey = map.entrySet().stream()

                .filter(entry -> entry.getKey().equals(key))

                .map(Map.Entry::getKey)

                .findFirst();

 

        if (foundKey.isPresent()) {

            // Key found, iterate again to count position

            for (Map.Entry<String, Integer> entry : map.entrySet()) {

                if (entry.getKey().equals(key)) {

                    return position;

                }

                position++;

            }

        }

        return -1; // Key not found

    }

 

    public static void main(String[] args) {

         

        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();

        map.put("apple", 10);

        map.put("banana", 20);

        map.put("cherry", 30);

 

        int position = findKeyPosition(map, "banana");

 

        if (position != -1) {

            System.out.println("Key 'banana' found at position: " + position);

        } else {

            System.out.println("Key 'banana' not found");

        }

    }

}

In this approach, we use entrySet().stream() to create a Stream of key-value pairs from the map and use filter to filter the stream to keep only entries where the key matches the target key. We use map(Map.Entry::getKey) is to extract just the keys from the filtered entries and use findFirst to retrieve the first matching key wrapped in an Optional. If the Optional contains a value (meaning the key was found), we iterate through the entire entrySet again.

Inside the loop, we compare the current entry’s key with the target key. If there’s a match, we return the current position as it represents the target key’s position based on insertion order.

4. Using keySet() and List.copyOf() (Java 10+)

This approach leverages the List.copyOf() method to create a list from the key set and then find the index of the key.

LinkedHashMapListCopyOf.java

public class LinkedHashMapListCopyOf {

 

    public static void main(String[] args) {

        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();

        linkedHashMap.put("apple", 10);

        linkedHashMap.put("banana", 20);

        linkedHashMap.put("cherry", 30);

        linkedHashMap.put("orange", 40);

 

        String key = "orange";

        int position = getPositionOfKey(linkedHashMap, key);

        System.out.println("The position of the key \"" + key + "\" is: " + position);

    }

 

    public static <K, V> int getPositionOfKey(LinkedHashMap<K, V> map, K key) {

        List<K> keyList = List.copyOf(map.keySet());

        return keyList.indexOf(key);

    }

}

In this approach, List.copyOf(map.keySet()) method creates an unmodifiable copy of the key set from the LinkedHashMap and we use keyList.indexOf(key method to return the index of the specified key in the list. The output is:

The Posotion of the key "orange" is: 3

Example Output Using List.copyOf for Java LinkedHashMap Key Position

5. Conclusion

In this article, we explored several methods to find the position of a key-value pair in a Java LinkedHashMap. We began with a straightforward iteration approach, followed by converting the key set to a list for direct index retrieval. We also demonstrated the power of Java 8’s Stream API for a more functional programming solution. Additionally, we leveraged Java 10’s List.copyOf() method to create an unmodifiable list from the key set, facilitating easy position finding. Each method showcases different aspects of Java’s rich API and highlights various ways to achieve the same goal.

Source: javacodegeeks.com

Continue reading