How do I gracefully shut down an ExecutorService?

By I Wayan Saryada in Concurrency 0 Comment

To gracefully shut down an ExecutorService in Java, you should follow these steps:

  1. Call shutdown():
    • This will prevent the ExecutorService from accepting any new tasks while allowing already submitted tasks to be completed.
  2. Wait for Termination:
    • You can use awaitTermination(long timeout, TimeUnit unit) to wait for a specified amount of time for all tasks to finish their execution.
  3. Force Shutdown if Necessary:
    • If tasks haven’t completed after the wait period, you can call shutdownNow() to attempt to cancel all currently executing tasks and halt further task execution.

Here’s an example:

package org.kodejava.util.concurrent;

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

public class GracefulShutdownExample {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        // Submit some tasks to the executor
        for (int i = 0; i < 10; i++) {
            executorService.submit(() -> {
                try {
                    System.out.println("Task executing: " + Thread.currentThread().getName());
                    Thread.sleep(1000); // Simulate task processing
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.out.println("Task interrupted: " + Thread.currentThread().getName());
                }
            });
        }

        // Initiate graceful shutdown
        executorService.shutdown();
        System.out.println("Shutdown initiated");

        try {
            // Wait for all tasks to finish execution or timeout
            if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
                System.out.println("Timeout reached, forcing shutdown...");
                // Force shutdown if tasks are still running
                executorService.shutdownNow();

                // Wait again to ensure shutdownNow has time to interrupt tasks
                if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
                    System.err.println("Executor did not terminate");
                }
            }
        } catch (InterruptedException e) {
            // Re-cancel if the current thread was interrupted
            executorService.shutdownNow();
            // Preserve interrupt status
            Thread.currentThread().interrupt();
        }

        System.out.println("Executor service shut down");
    }
}

Explanation of Key Methods:

  • shutdown():
    • Initiates an orderly shutdown where previously submitted tasks are executed but no new tasks are accepted.
  • awaitTermination(long timeout, TimeUnit unit):
    • Waits for the executor to terminate for the given timeout. Returns true if termination occurs within the timeout, false otherwise.
  • shutdownNow():
    • Attempts to stop all running tasks and halts task processing. It returns a list of tasks that were waiting to be executed.

Best Practices:

  • Always include exception handling for InterruptedException.
  • Use a timeout value that suits your application’s requirements.
  • Avoid forcing a shutdown (shutdownNow()) unless absolutely necessary, as it can leave tasks in an inconsistent state.

By following these steps, you can shut down your ExecutorService gracefully and ensure that resources are properly released.

How do I submit multiple tasks and get results using invokeAll?

By I Wayan Saryada in Concurrency 0 Comment

To submit multiple tasks and get results using invokeAll in Java, you can make use of the ExecutorService. The invokeAll method submits a collection of Callable tasks to the executor and waits for all of them to complete. Once completed, it returns a list of Future objects, each representing the result of a corresponding task.

Here’s how it works:

  1. Create a collection of Callable tasks: These tasks are units of work that the executor will execute in parallel.
  2. Submit the tasks using invokeAll: The invokeAll method blocks until all tasks are complete or timed out.
  3. Retrieve the results from the Future objects: Each Future object allows you to get the result of its corresponding task or check for exceptions.

Example Code

package org.kodejava.util.concurrent;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

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

      // Create a collection of Callable tasks
      List<Callable<String>> tasks = new ArrayList<>();
      tasks.add(() -> {
         // Simulate doing some work
         Thread.sleep(1000);
         return "Task 1 completed";
      });
      tasks.add(() -> {
         Thread.sleep(2000);
         return "Task 2 completed";
      });
      tasks.add(() -> {
         Thread.sleep(1500);
         return "Task 3 completed";
      });

      try {
         // Submit the tasks and wait for all of them to complete
         List<Future<String>> results = executorService.invokeAll(tasks);

         // Iterate through the futures to retrieve the results
         for (Future<String> future : results) {
            try {
               // Get the result of each task
               System.out.println(future.get());
            } catch (ExecutionException e) {
               System.err.println("Task encountered an issue: " + e.getMessage());
            }
         }
      } catch (InterruptedException e) {
         System.err.println("Task execution was interrupted: " + e.getMessage());
      } finally {
         // Shutdown the executor service
         executorService.shutdown();
      }
   }
}

Explanation:

  1. ExecutorService:
    • A thread pool is created (Executors.newFixedThreadPool(3)), which allows up to 3 threads to run simultaneously.
  2. List of Callable tasks:
    • Each task implements the Callable interface and returns a result. For example, the tasks simulate work by Thread.sleep() and return a string.
  3. invokeAll Method:
    • executorService.invokeAll(tasks) submits all tasks at once and blocks until all tasks are complete.
  4. Retrieving Results:
    • The method returns a list of Future objects, where future.get() is used to retrieve the result of each task.
  5. Exceptions:
    • Handle InterruptedException (if the current thread is interrupted) and ExecutionException (if a task fails with an exception).
  6. Shutdown the Executor:
    • Always call shutdown() to properly terminate the executor service and release resources.

Output:

Task 1 completed
Task 3 completed
Task 2 completed

(Note: The order may vary since the tasks run concurrently.)

Keynotes:

  • Use ExecutorService to manage thread pools efficiently.
  • The invokeAll method blocks until all tasks are complete.
  • Handle exceptions like InterruptedException and ExecutionException.
  • Always shut down the executor service to free resources.

How to monitor memory with Java 10’s improved GC interface

By I Wayan Saryada in Java 10, Management 0 Comment

Java 10 introduced enhancements to the Garbage Collection (GC) interface through the JEP 304: GC Interface, which abstracts garbage-collection implementations to improve integration and monitoring capabilities. While these improvements primarily simplify the addition of new garbage collectors to the JVM, they can also be leveraged to monitor memory usage and GC behavior in real time.

Here’s how to monitor memory using Java 10’s improved GC interface.

Key Concepts

The primary tools for monitoring memory and garbage collection (from Java 10 onward) include:
1. java.lang.management package: Interfaces and classes such as GarbageCollectorMXBean, MemoryMXBean, and MemoryPoolMXBean are still accessible.
2. java.util.logging or external libraries: For logging GC activity.
3. New Unified Logging framework: Can be used to log GC activities in detail starting with Java 9.

Steps to Monitor Memory Using Java 10 GC Interface:

1. Use the GarbageCollectorMXBean

The GarbageCollectorMXBean allows you to track details such as the number of collections, total collection time, and more.

Here’s an example:

package org.kodejava.lang.management;

import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;
import java.util.List;

public class GcMonitoringDemo {
    public static void main(String[] args) {
        // Get all GC beans
        List<GarbageCollectorMXBean> gcBeans = ManagementFactory.getGarbageCollectorMXBeans();

        for (GarbageCollectorMXBean gcBean : gcBeans) {
            System.out.println("Garbage Collector: " + gcBean.getName());
            System.out.println("Collection count: " + gcBean.getCollectionCount());
            System.out.println("Collection time (ms): " + gcBean.getCollectionTime());
        }

        // Simulate some memory load
        for (int i = 0; i < 10000; i++) {
            String[] temp = new String[1000];
            temp = null; // Let the memory be collected
        }

        System.out.println("After memory load:");
        for (GarbageCollectorMXBean gcBean : gcBeans) {
            System.out.println("Garbage Collector: " + gcBean.getName());
            System.out.println("Collection count: " + gcBean.getCollectionCount());
            System.out.println("Collection time (ms): " + gcBean.getCollectionTime());
        }
    }
}

Output will include:

  • Garbage collector names based on the JVM (e.g., G1 Young Generation, G1 Old Generation, etc.).
  • Collection count and total collection time.

2. Analyze Memory Usage via the MemoryMXBean

The MemoryMXBean interface helps monitor heap and non-heap memory usage.

package org.kodejava.lang.management;

import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;

public class MemoryMonitoringDemo {
    public static void main(String[] args) {
        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();

        // Get heap memory usage
        MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
        System.out.println("Heap Memory Usage:");
        System.out.println("  Init: " + heapMemoryUsage.getInit());
        System.out.println("  Used: " + heapMemoryUsage.getUsed());
        System.out.println("  Max: " + heapMemoryUsage.getMax());
        System.out.println("  Committed: " + heapMemoryUsage.getCommitted());

        // Get non-heap memory usage
        MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
        System.out.println("Non-Heap Memory Usage:");
        System.out.println("  Init: " + nonHeapMemoryUsage.getInit());
        System.out.println("  Used: " + nonHeapMemoryUsage.getUsed());
        System.out.println("  Max: " + nonHeapMemoryUsage.getMax());
        System.out.println("  Committed: " + nonHeapMemoryUsage.getCommitted());
    }
}

3. Monitor GC Using Unified Logging

Starting from Java 9, the new Unified Logging Framework allows you to log GC activities comprehensively. You can enable it with various JVM options.

For example:

java -Xlog:gc* -XX:+UseG1GC -jar YourApplication.jar

Additional useful options include:

  • -Xlog:gc+heap: Logs GC and heap events.
  • -Xlog:gc+age: Logs information about object aging.
  • -Xlog:gc*=info,safepoint: Logs GC and safe-point information.

Output in the log will provide in-depth GC activity for analysis.

4. Advanced Real-Time Monitoring with JFR (Java Flight Recorder)

Java Flight Recorder (JFR) is another tool integrated into the JVM that enables detailed profiling and monitoring, including GC data.

java -XX:StartFlightRecording=filename=recording.jfr,duration=60s -XX:+UnlockCommercialFeatures -jar YourApplication.jar

After this recording, you can analyze recording.jfr in tools such as Java Mission Control (JMC).

5. Third-Party Tools for Active Monitoring

You can also leverage external tools or libraries:

  • VisualVM: Provides a GUI-based approach to monitor GC and memory usage.
  • micrometer.io: A metrics library for monitoring in microservices.
  • Prometheus + Grafana: To build custom dashboards for GC and memory metrics.

Conclusion

  • For basic JVM-based monitoring, use the GarbageCollectorMXBean and MemoryMXBean.
  • For detailed runtime logging of GC behavior, use the Unified Logging Framework.
  • For comprehensive profiling and diagnostics, use tools like JFR or VisualVM.

Java 10’s GC interface improvements make it easier to add and monitor new garbage collector implementations, but the existing Java Management Extensions (JMX) and logging tools are still central to effective memory monitoring.

How do I avoid Optional performance pitfalls in high-frequency code paths?

By I Wayan Saryada in Util Package 0 Comment

When working with Java’s Optional in high-frequency code paths, it’s essential to understand and avoid the performance pitfalls associated with its usage. Although Optional provides functional-style coding benefits and helps prevent NullPointerException, it introduces additional overhead due to extra object creation and functional programming constructs. Here are some recommendations to ensure optimal performance:

1. Avoid Optional in Performance-Critical Return Paths

  • Pitfall: Using Optional as a return type results in heap allocation, which can impact performance in high-frequency code paths.
  • Resolution: Prefer returning null or an alternative (e.g., a special value) in performance-critical sections of the code where object creation is a concern. Reserve Optional for APIs where readability and null-safety are a higher priority.
// Example of avoiding Optional in a performance-critical path
@Nullable
public String findValue(Map<String, String> map, String key) {
   return map.containsKey(key) ? map.get(key) : null;
}

2. Minimize Optional Creation and Chaining

  • Pitfall: Frequent creation of Optional instances for chaining operations like map, filter, etc., can result in unnecessary allocations and functional overhead.
  • Resolution: Avoid repeated and nested transformations. If you need chains of operations, consider processing directly instead of creating multiple intermediate Optional instances.
// Inefficient
Optional<String> result = Optional.ofNullable(value)
                                  .filter(v -> v.startsWith("prefix"))
                                  .map(v -> transform(v));

// More efficient
if (value != null && value.startsWith("prefix")) {
   result = transform(value);
}

3. Avoid Optional for Fields in High-Frequency Objects

  • Pitfall: Using Optional for class fields can be wasteful in terms of memory and lead to extra indirection.
  • Resolution: Use null instead of Optional for fields and handle null-safety in getters or utility methods.
// Avoid this:
private Optional<String> value; 

// Prefer:
private String value; // Use nullable reference directly.

For optional fields, you can provide clear access methods:

public Optional<String> getValue() {
   return Optional.ofNullable(value);
}

4. Be Careful with Streams and Optionals

  • Pitfall: Using Optional within streams often results in additional unnecessary wrapping and unwrapping.
  • Resolution: Avoid excessive use of Optional in stream pipelines, especially in loops or large datasets.
// Inefficient
List<String> filtered = items.stream()
                            .map(item -> Optional.ofNullable(item).filter(...))
                            .filter(Optional::isPresent)
                            .map(Optional::get)
                            .collect(Collectors.toList());

// Efficient
List<String> filtered = items.stream()
                            .filter(Objects::nonNull)
                            .filter(...)
                            .collect(Collectors.toList());

5. Do Not Use Optional in Constructor Parameters

  • Pitfall: Passing Optional parameters in constructors (or methods) can create unnecessary wrapping and unwrapping operations.
  • Resolution: Use nullable parameters, document their behavior, and handle the null checks internally.
// Avoid this:
public MyClass(Optional<String> optionalParam) { }

// Prefer this:
public MyClass(@Nullable String param) {
   this.value = param != null ? param : "default";
}

6. Combine Null Checks and Optional Usage

  • Pitfall: Overusing Optional for null-safe data access can introduce hard-to-read or inefficient code.
  • Resolution: Consider combining plain null checks with Optional for better performance.
// Inefficient:
Optional.ofNullable(obj)
       .map(v -> v.getNested())
       .orElse(defaultValue);

// More efficient:
if (obj != null && obj.getNested() != null) {
   return obj.getNested();
}
return defaultValue;

7. Optimize for Hot Code Paths

  • For hot code paths (executed very frequently), prioritize raw performance over readability. Focus on reducing heap allocations and method calls. Direct null checks and traditional constructs are generally more efficient in such cases.

8. Profile and Measure

  • Always profile your code to identify if Optional is a bottleneck. Use tools like Java Mission Control, YourKit, or VisualVM to analyze if garbage collection or method invocation from Optional usage contributes to performance issues.

Trade-offs Between Safety and Performance

While avoiding Optional can improve performance, it comes at the cost of reduced readability and safety. Evaluate whether the potential performance gains outweigh the benefits of reducing null-related errors.

By following these strategies, you can achieve a good balance between writing clean, maintainable code and not sacrificing performance in high-frequency code paths.

How do I write Optional-aware utility methods?

By I Wayan Saryada in Util Package 0 Comment

Writing Optional-aware utility methods in Java involves keeping in mind the design of the Optional class, which is meant to represent potentially absent values in a neat, declarative way. Good utility methods avoid nulls and integrate smoothly with the existing Optional API. Here are a few practices and examples to guide you:

1. Use Optional as Arguments

Accept Optional as a parameter only if it provides additional semantic meaning (e.g., “the absence of this parameter has semantic importance”). Otherwise, it’s better to accept nullable values and wrap them in Optional inside the method.

Example: Create a utility that gracefully handles an optional string.

public static Optional<String> toUpperIfPresent(Optional<String> input) {
   return input.map(String::toUpperCase);
}

Usage:

Optional<String> result = toUpperIfPresent(Optional.of("hello"));
result.ifPresent(System.out::println); // Output: HELLO

2. Never Use Optional in Entity Fields or Collections

Avoid storing Optional in fields of objects or in collections. Instead, use Optional in utility methods or intermediate computations.

3. Return Optional Thoughtfully

Utility methods that retrieve values should return Optional where the absence of a value is expected and not an error.

Example: Retrieve a value safely from a map.

public static <K, V> Optional<V> getFromMapSafely(Map<K, V> map, K key) {
   return Optional.ofNullable(map.get(key));
}

Usage:

Map<String, String> data = Map.of("key1", "value1");
Optional<String> value = getFromMapSafely(data, "key1");
value.ifPresent(System.out::println); // Output: value1

4. FlatMap for Chaining

Use flatMap to chain Optional-returning methods.

Example: A nested Optional scenario.

public static Optional<String> getLastWord(String sentence) {
   return Optional.ofNullable(sentence)
           .map(s -> s.split("\\s+"))
           .flatMap(words -> words.length > 0 ? Optional.of(words[words.length - 1]) : Optional.empty());
}

Usage:

Optional<String> lastWord = getLastWord("Hello world");
lastWord.ifPresent(System.out::println); // Output: world

5. Optionally Process or Transform a Value

Include utility methods that make it easier to process or transform only when a value is present.

Example: Apply a transformation only if a value exists.

public static <T, R> Optional<R> transformIfPresent(Optional<T> opt, Function<T, R> transformer) {
   return opt.map(transformer);
}

Usage:

Optional<Integer> length = transformIfPresent(Optional.of("test"), String::length);
System.out.println(length); // Output: Optional[4]

6. Default Values

Provide utility methods for defaults to handle absent values.

Example: Safely get a default value if Optional is empty.

public static <T> T getOrDefault(Optional<T> opt, T defaultValue) {
   return opt.orElse(defaultValue);
}

Usage:

String value = getOrDefault(Optional.empty(), "default");
System.out.println(value); // Output: default

7. Chaining with Stream-Like Behavior

Combine multiple computations using Optional chaining.

Example: Extract and manipulate a value.

public static Optional<Integer> extractAndModify(Optional<String> input) {
   return input.filter(str -> !str.isEmpty())
               .map(String::length)
               .filter(len -> len > 2);
}

Usage:

Optional<Integer> result = extractAndModify(Optional.of("test"));
result.ifPresent(System.out::println); // Output: 4

8. Throw Exceptions

Use orElseThrow to explicitly indicate failure when a value is mandatory.

Example: Safeguard missing data.

public static <T> T getMandatoryValue(Optional<T> opt) {
   return opt.orElseThrow(() -> new IllegalStateException("Value is required"));
}

Usage:

String value = getMandatoryValue(Optional.of("data"));
System.out.println(value); // Output: data

9. Avoid Explicit null with Optional

Prevent code that creates or operates on Optional with null, such as Optional.of(null) since this will throw NullPointerException.

Example:

  • Good:
Optional<String> opt = Optional.ofNullable(input);
  • Bad:
Optional<String> opt = Optional.of(input); // Throws exception if input is null

10. Utility Method Summary

Here’s a consolidated utility class example:

package org.kodejava.util;

import java.util.Map;
import java.util.Optional;
import java.util.function.Function;

public class OptionalUtils {

    public static <T> T getOrDefault(Optional<T> opt, T defaultValue) {
        return opt.orElse(defaultValue);
    }

    public static <K, V> Optional<V> getFromMapSafely(Map<K, V> map, K key) {
        return Optional.ofNullable(map.get(key));
    }

    public static <T, R> Optional<R> transformIfPresent(Optional<T> opt, Function<T, R> transformer) {
        return opt.map(transformer);
    }

    public static <T> T getMandatoryValue(Optional<T> opt) {
        return opt.orElseThrow(() -> new IllegalStateException("Value is required"));
    }

    public static Optional<String> toUpperIfPresent(Optional<String> input) {
        return input.map(String::toUpperCase);
    }
}

Usage:

Optional<String> opt = Optional.of("example");
String upper = OptionalUtils.toUpperIfPresent(opt).orElse("default");
System.out.println(upper); // Output: EXAMPLE

By following these practices, you build utilities that keep optional semantics clear and align with Java’s functional approach to handling absent values.