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 download a file from an SSH server using JSch SFTP?

By I Wayan Saryada in JSch 0 Comment

To download a file from an SSH server using JSch SFTP, you can use the ChannelSftp class from the JSch library. Below is an example of how to achieve this:

Code Example: Downloading a file using JSch SFTP

The JSch library is used to establish an SSH connection to an SFTP server and transfer files. Here’s a step-by-step guide:

package org.kodejava.jsch;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Session;

import java.io.FileOutputStream;

public class SFTPDownloadExample {
   public static void main(String[] args) {
      String sftpHost = "sftp.example.com";
      int sftpPort = 22;
      String sftpUser = "username";
      String sftpPassword = "password";
      String remoteFile = "/path/to/remote/file.txt";
      String localFile = "local-file-path.txt";

      Session session = null;
      Channel channel = null;
      ChannelSftp channelSftp = null;

      try {
         // Initialize JSch
         JSch jsch = new JSch();

         // Create session
         session = jsch.getSession(sftpUser, sftpHost, sftpPort);

         // Set the password
         session.setPassword(sftpPassword);

         // Configure strict host key checking (optional)
         session.setConfig("StrictHostKeyChecking", "no");

         // Connect the session
         System.out.println("Connecting to the SFTP server...");
         session.connect();
         System.out.println("Connected successfully.");

         // Open the SFTP channel
         channel = session.openChannel("sftp");
         channel.connect();
         channelSftp = (ChannelSftp) channel;

         // Download the file
         System.out.println("Downloading file...");
         channelSftp.get(remoteFile, localFile);
         System.out.println("File downloaded to: " + localFile);

      } catch (Exception e) {
         e.printStackTrace();
      } finally {
         // Clean up resources
         if (channelSftp != null) {
            channelSftp.disconnect();
         }
         if (channel != null) {
            channel.disconnect();
         }
         if (session != null) {
            session.disconnect();
         }
      }
   }
}

Explanation of the Code

  1. Set up connection details: Set the SFTP server’s host, port, username, password, the path to the remote file, and the local file.
  2. JSch initialization:
    • Create a Session object with user credentials (host, port, username, and password).
    • Use session.setConfig("StrictHostKeyChecking", "no") to skip host key verification (use for testing; not recommended for production due to security risks).
    • Connect to the server using session.connect().
  3. Open the SFTP channel:
    • Open a channel to the server with session.openChannel("sftp").
    • Cast the channel to ChannelSftp and connect.
  4. Download the file:
    • Use ChannelSftp.get(remoteFile, localFile) to download the remote file to the specified local path.
  5. Clean up resources:
    • Disconnect the ChannelSftp, Channel, and Session objects to free up resources.

Output Example

If successful, the program outputs the following:

Connecting to the SFTP server...
Connected successfully.
Downloading file...
File downloaded to: local-file-path.txt

Note

  • If your SFTP server uses public/private keys, you can use jsch.addIdentity("path/to/private_key") before initiating the session instead of a password.
  • Always handle exceptions and manage resources carefully in a real-world application to ensure robustness.

This example should work to download files via SFTP in Java.

Maven Dependencies

<dependency>
    <groupId>com.jcraft</groupId>
    <artifactId>jsch</artifactId>
    <version>0.1.55</version>
</dependency>

Maven Central

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.

How do I use Optional with custom monads or functional libraries?

By I Wayan Saryada in Util Package 0 Comment

Using Optional with custom monads or functional programming libraries can enhance code readability and handle null-like scenarios effectively. Here’s how you can integrate Optional with custom monads or functional programming libraries:

1. Understanding Optional in Functional Context

Optional is essentially a simplified monad used to represent the presence or absence of a value. Custom monads often introduce additional context, like logging (Writer), computation (IO), or error propagation (Either). You need to interoperate by converting between Optional and your custom monads.

2. Use Case: Wrapping Optional in Custom Monads

You can seamlessly integrate Optional with your monads using the following steps:

a) Lifting Optional into a Monad

If you have an Optional value and want to lift it into another monad (e.g., Either, Try, etc.):

Optional<String> optionalValue = Optional.of("Hello");

Either<String, String> eitherValue = optionalValue
   .map(Either::<String, String>right) // Wrap the value in a Right
   .orElse(Either.left("Default value")); // Provide a Left value for absent option

b) From Custom Monad to Optional

Converting a value from a monadic type back to Optional:

Suppose you are using a library with custom monads like Either<L, R>. To extract the right value into an Optional:

Either<String, String> eitherValue = Either.right("Hello");

Optional<String> optionalValue = eitherValue
   .toOptional(); // Assuming your library has this method

If your library doesn’t support this natively, you can write utility methods:

public static <L, R> Optional<R> eitherToOptional(Either<L, R> either) {
   return either.isRight() ? Optional.of(either.getRight()) : Optional.empty();
}

3. Higher-Order Functions: Combine Optional with Streams or Collections

Libraries like Vavr or Arrow provide monadic types as part of their standard functional programming suite. Interoperating with them requires mapping and flat-mapping similar to Optional.

Example: Using Vavr’s Option with Java’s Optional

Converting between Java’s Optional and Vavr’s Option:

Optional<String> javaOptional = Optional.of("Functional!");
io.vavr.control.Option<String> vavrOption = io.vavr.control.Option.ofOptional(javaOptional);

// Vice versa: Convert Vavr's Option to Java's Optional
Optional<String> convertedOptional = vavrOption.toJavaOptional();

Example: Handle Streams with Optional

If your monad uses Java functions:

Optional<String> optionalValue = Optional.of("Monad");
List<Optional<String>> optionalList = Arrays.asList(optionalValue);

List<String> unwrappedList = optionalList.stream()
   .flatMap(Optional::stream) // Java 9+ Optional::stream
   .collect(Collectors.toList());

4. Custom Monad Utility Using Optional

Suppose you want to use Optional in a custom monadic type:

package org.kodejava.util;

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

public class CustomMonad<T> {
    private final Optional<T> optional;

    public CustomMonad(T value) {
        this.optional = Optional.ofNullable(value);
    }

    public <R> CustomMonad<R> flatMap(Function<T, CustomMonad<R>> mapper) {
        if (optional.isEmpty()) return new CustomMonad<>(null);
        return mapper.apply(optional.get());
    }

    public Optional<T> toOptional() {
        return optional;
    }

    public T getOrElse(T defaultValue) {
        return optional.orElse(defaultValue);
    }
}

Use:

CustomMonad<String> monad = new CustomMonad<>("Hello");

CustomMonad<String> upperCaseMonad = monad.flatMap(
   value -> new CustomMonad<>(value.toUpperCase()));

System.out.println(upperCaseMonad.toOptional().orElse("Fallback"));

5. Chaining Optional with Monads

If your monad (Optional, Either, or others) supports chaining via flatMap, you can chain operations together efficiently:

Optional<String> optional = Optional.of("Monad");

Optional<Integer> length = optional.flatMap(val -> Optional.of(val.length()));

If chaining involves multiple monads, interconversion techniques (discussed above) become useful.

6. Error Handling with Optional

When pairing Optional with an error-propagating monad like Either or Try, handle absence cases explicitly:

Optional<String> optional = Optional.empty();

Try<String> result = Try.of(() -> optional.orElseThrow(() -> new RuntimeException("Empty!")));

Integrating Optional with custom monads or functional programming libraries usually requires interconversion or adapting map/flatMap semantics to maintain behavior. Using third-party libraries like Vavr can further expand the functional possibilities with their enriched monad ecosystem.