How do I create a temporary file with Files.createTempFile()?

By Wayan in IO 0 Comment

To create a temporary file using java.nio.file.Files.createTempFile, you can use one of two main overloaded methods. This is part of the Java NIO.2 API and is generally preferred over the older File.createTempFile because it returns a Path object and allows for better error handling and file attributes.

1. In the Default Temporary Directory

If you only care about the prefix and suffix, Java will place the file in the system’s default temporary folder.

package org.kodejava.nio;

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

public class TempFileExample {
    public static void main(String[] args) {
        try {
            // Prefix: "log_", Suffix: ".tmp"
            // Result: /tmp/log_123456789.tmp (the path varies by OS)
            Path tempFile = Files.createTempFile("log_", ".tmp");

            System.out.println("Temporary file created at: " + tempFile);

            // Optionally, delete the file on exit (NIO doesn't have a direct 
            // method like File, so we usually use a shutdown hook or delete
            // manually)
            tempFile.toFile().deleteOnExit();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. In a Specific Directory

If you want the temporary file to be created in a specific folder, pass a Path as the first argument.

package org.kodejava.nio;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;

public class CustomTempFileExample {
    public static void main(String[] args) {
        Path customDir = Paths.get("C:/my_app/temp");

        try {
            // Ensure the directory exists first
            if (Files.notExists(customDir)) {
                Files.createDirectories(customDir);
            }

            Path tempFile = Files.createTempFile(customDir, "data_", ".dat");
            System.out.println("File created in custom dir: " + tempFile);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Key Differences to Note:

  • Prefix/Suffix: The prefix must be at least three characters long. The suffix can be null, in which case .tmp is used.
  • Security: Files.createTempFile creates the file with restricted permissions (readable/writable only by the owner) by default on many systems, which is more secure than the older File.createTempFile.
  • Return Type: It returns a java.nio.file.Path object, which is the modern way to handle file paths in Java.

How do I use Files.lines() to process a text file line by line?

By Wayan in IO 0 Comment

To use Files.lines() to process a text file line by line in Java, you should follow the pattern of returning a Stream<String> within a try-with-resources block. This approach is memory-efficient because it reads the file lazily, meaning it doesn’t load the entire file into memory at once.

Basic Implementation

package org.kodejava.nio;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;

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

        // Use try-with-resources to ensure the stream (and underlying file) is closed
        try (Stream<String> lines = Files.lines(path)) {
            lines.forEach(System.out::println);
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        }
    }
}

Advanced Processing (Filtering and Mapping)

The power of Files.lines() comes from the Stream API, allowing you to filter, transform, or search through the file content easily:

try (Stream<String> lines = Files.lines(path)) {
    long count = lines
        .filter(line -> line.contains("ERROR")) // Only keep lines with "ERROR"
        .map(String::trim)                       // Remove whitespace
        .peek(System.out::println)               // Print each matching line
        .count();                                // Count the occurrences

    System.out.println("Total errors found: " + count);
} catch (IOException e) {
    e.printStackTrace();
}

Key Considerations:

  1. Try-with-Resources is Mandatory: Unlike most streams, the stream returned by Files.lines() holds an open resource (the file handle). If you don’t close it, you may run into a “too many open files” error.
  2. Character Encoding: By default, Files.lines() uses UTF-8. If your file uses a different encoding (like ISO-8859-1), you can specify it as a second argument: 
    Files.lines(path, StandardCharsets.ISO_8859_1)

  3. Performance: For very large files, Files.lines() is significantly more efficient than Files.readAllLines(), which would attempt to store every line in a List<String>, potentially causing an OutOfMemoryError.

How do I use Files.newBufferedReader() with try-with-resources?

By Wayan in IO 0 Comment

Using Files.newBufferedReader with a try-with-resources block is the best practice for reading files in Java. Since BufferedReader implements AutoCloseable, the try-with-resources statement ensures that the file handle is automatically closed when the block is finished, even if an exception occurs.

Here is how you can implement it:

Basic Usage

This is the simplest way to read a file line-by-line using the default UTF-8 charset.

package org.kodejava.nio;

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

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

        // The resource is declared inside the try parentheses
        try (BufferedReader reader = Files.newBufferedReader(path)) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            // Handle potential issues like a file not found or access errors
            e.printStackTrace();
        }
    }
}

Key Highlights

  • Automatic Cleanup: You don’t need a finally block to call reader.close().
  • Charset Support: If your file uses a specific encoding (like ISO-8859-1), you can pass it as a second argument: 
    try (BufferedReader reader = Files.newBufferedReader(path, StandardCharsets.ISO_8859_1)) { ... }
  • Modern Alternative: Since you are using Java 25, if you want to read all lines into a stream for processing, you can use the lines() method inside the block: 
    try (BufferedReader reader = Files.newBufferedReader(path)) {
    reader.lines().forEach(System.out::println);
}

Why use Files.newBufferedReader over new BufferedReader(new FileReader(...))?

  1. Path API: It works seamlessly with java.nio.file.Path, which is more robust than the old File class.
  2. Explicit Charset: It defaults to UTF-8 (unlike older methods which might use the system’s default encoding), making your code more portable.
  3. Better Error Handling: It provides more descriptive IOException subclasses (like NoSuchFileException).

How do I read large files with streams?

By Wayan in IO 0 Comment

Reading large files in Java efficiently is best achieved by using Stream-based APIs that process the file line-by-line or chunk-by-chunk. This prevents loading the entire file into memory (preventing OutOfMemoryError).

Here are the most common and efficient ways to do this:

1. Using Files.lines() (Recommended)

This is the most modern and idiomatic way in Java. It returns a Stream<String> where each element is a line from the file. It reads the lines lazily, meaning it only keeps a small portion of the file in memory at any given time.

Important: Always use a try-with-resources block to ensure the file handle is closed.

package org.kodejava.nio;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class LargeFileReader {
    public static void main(String[] args) {
        Path path = Paths.get("D:/large-file.txt");

        try (Stream<String> lines = Files.lines(path)) {
            lines.filter(line -> line.contains("Error")) // Example processing
                    .forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. Using BufferedReader.lines()

If you already have a BufferedReader (for example, if you’re dealing with a specific character encoding), you can use its .lines() method. This also returns a lazy stream.

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

try (BufferedReader br = new BufferedReader(new FileReader("large-file.txt"))) {
    br.lines()
      .map(String::toLowerCase)
      .forEach(line -> {
          // Process each line here
      });
} catch (IOException e) {
    e.printStackTrace();
}

3. Using Scanner (For Tokens)

If you need to read tokens (like words or numbers) rather than full lines, Scanner is useful. However, it is generally slower than BufferedReader.

import java.util.Scanner;
import java.io.File;

try (Scanner scanner = new Scanner(new File("large-file.txt"))) {
    while (scanner.hasNextLine()) {
        String line = scanner.nextLine();
        // Process line
    }
} catch (IOException e) {
    e.printStackTrace();
}

Summary of Tips for Large Files:

  • Lazy Evaluation: Operations like filter and map on Java Streams are lazy. They don’t process the data until a terminal operation (like forEach or collect) is called.
  • Memory Efficiency: The Stream API ensures that you aren’t storing the whole file in a List<String>, which would quickly crash your app for multi-gigabyte files.
  • Parallelism: For huge files, you can use .parallel() on the stream. However, be careful as IO-bound tasks often don’t benefit much from parallel streams unless the processing logic per line is very heavy.

How do I use NIO Path.of() instead of Paths.get()?

By Wayan in IO, Java 11 0 Comment

In Java 11 and later, Path.of() is the preferred way to create Path instances, effectively replacing Paths.get().

Here is how you can use it:

1. Basic Usage (Replacing Paths.get)

The syntax is almost identical. It accepts a string or a sequence of strings to join into a path.

package org.kodejava.nio;

import java.nio.file.Path;

public class PathExample {
    public static void main(String[] args) {
        // Using a single string
        Path path1 = Path.of("C:/logs/app.log");

        // Using multiple strings (varargs) to join paths
        Path path2 = Path.of("C:", "logs", "app.log");

        System.out.println(path2); // Outputs: C:\logs\app.log (on Windows)
    }
}

2. Working with URIs

Path.of() also has an overload that accepts a URI object, just like Paths.get(URI uri).

import java.net.URI;
import java.nio.file.Path;

Path pathFromUri = Path.of(URI.create("file:///C:/logs/app.log"));

Why use Path.of() instead of Paths.get()?

  • Cleaner API: Path is the primary interface. Path.of() keeps the logic within the interface itself rather than relying on a separate utility class (Paths).
  • Modern Standard: Paths.get() was introduced in Java 7 as a bridge. Java 11 introduced Path.of() as the modern, static factory method on the interface.
  • Consistency: Most modern Java APIs (like List.of(), Set.of()) use this naming convention.

How do I use Files.mismatch() to compare files?

By Wayan in IO, Java 12 0 Comment

In Java, java.nio.file.Files.mismatch(Path, Path) is a powerful method introduced in Java 12 that allows you to compare the contents of two files efficiently. It returns the position of the first byte where the two files differ, or -1L if they are identical.

How to use Files.mismatch

Here is a basic example of how to implement it:

package org.kodejava.nio;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class FileCompare {
    public static void main(String[] args) {
        Path path1 = Path.of("file1.txt");
        Path path2 = Path.of("file2.txt");

        try {
            long mismatch = Files.mismatch(path1, path2);

            if (mismatch == -1L) {
                System.out.println("Files are identical.");
            } else {
                System.out.println("Files differ at byte position: " + mismatch);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Key Behaviors to Keep in Mind:

  1. Return Values:
    • -1L: The files are identical (same size and same content).
    • A non-negative value: The index of the first byte that differs.
    • File Size Mismatch: If one file is a prefix of the other, it returns the size of the smaller file as the mismatch point.
  2. Performance: Files.mismatch is generally faster than manual byte-by-byte comparison because it uses optimized internal buffers.
  3. Same Path: If you pass the exact same Path object (or two paths that point to the same file via Files.isSameFile), it returns -1L immediately without reading the content.
  4. Exceptions: It throws an IOException if there’s an error reading the files or if one of the paths does not exist.

How do I read and write files with Files.readString() and Files.writeString()?

By Wayan in IO, Java 11 0 Comment

In Java, Files.readString and Files.writeString (introduced in Java 11) are the most straightforward ways to handle small-to-medium-sized text files. They handle the opening, closing, and encoding for you in a single line of code.

Here is how you can use them:

1. Reading a File to a String

Files.readString(Path) reads the entire content of a file into a String. By default, it uses UTF-8 encoding.

package org.kodejava.nio;

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;

public class ReadExample {
    public static void main(String[] args) {
        Path filePath = Path.of("example.txt");

        try {
            // Reads the whole file into a String using UTF-8
            String content = Files.readString(filePath);
            System.out.println(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. Writing a String to a File

Files.writeString(Path, CharSequence) writes text to a file. If the file doesn’t exist, it creates it. If it does exist, it overwrites it by default.

package org.kodejava.nio;

import java.nio.file.Files;
import java.nio.file.Path;
import java.io.IOException;
import java.nio.file.StandardOpenOption;

public class WriteExample {
    public static void main(String[] args) {
        Path filePath = Path.of("example.txt");
        String data = "Hello, Java developers!\nThis is a test.";

        try {
            // Overwrites the file with the string content
            Files.writeString(filePath, data);

            // To APPEND instead of overwrite, use StandardOpenOption:
            // Files.writeString(filePath, "\nMore data", StandardOpenOption.APPEND);

            System.out.println("File written successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Key Points to Remember:

  • Memory Usage: Both methods load the entire file content into memory. Do not use them for very large files (e.g., gigabyte-sized logs), as they could cause an OutOfMemoryError.
  • Encoding: Both methods use UTF-8 by default. If you need a different encoding, you can pass a Charset as an additional argument:
    Files.readString(path, StandardCharsets.ISO_8859_1);
  • Exceptions: Both methods throw IOException, so they must be used within a try-catch block or a method that declares throws IOException.
  • Path API: Use Path.of("path/to/file") (Java 11+) or Paths.get("path/to/file") to create the Path object needed for these methods.

How do I debug concurrency issues effectively?

By Wayan in Concurrency 0 Comment

Debugging concurrency issues (like deadlocks, race conditions, and thread starvation) can feel like chasing ghosts because they are often non-deterministic. Here’s a strategy to tackle them effectively using both design patterns and tools available in your environment.

1. Give Your Threads Meaningful Names

The default pool-1-thread-1 names are useless in a thread dump. By using a Custom Thread Factory, you can prefix threads based on their purpose (e.g., Email-Dispatcher-1, Database-Writer-2).

As shown in your project’s CustomThreadFactory.java:

// ... existing code ...
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, namePrefix + threadNumber.getAndIncrement());
            t.setDaemon(daemon);
            t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
// ... existing code ...

This simple change makes logs and debugger views instantly readable.

2. Leverage IntelliJ IDEA’s Concurrency Tools

IntelliJ has built-in features specifically for multithreaded debugging:

  • Thread Selector: When hit at a breakpoint, use the dropdown in the Debug Tool Window to switch between threads and see their individual call stacks.
  • Breakpoint Suspend Policy: Right-click a breakpoint and change “Suspend” from All to Thread. This allows other threads to keep running while you inspect one, which is crucial for reproducing race conditions.
  • Async Stack Traces: Enable “Instrumenting agent” in Settings -> Build, Execution, Deployment -> Debugger -> Async Stack Traces. This stitches together stack traces across CompletableFuture or ExecutorService boundaries.

3. Analyze Thread Dumps

If your application “freezes,” it’s likely a deadlock.

  • Capture a Dump: In IntelliJ, use Process Console -> Tasks -> Attach Debugger or jstack <pid> from the terminal.
  • What to Look For: Look for threads in the BLOCKED state. Modern JVMs are quite good at detecting deadlocks and will explicitly list them at the bottom of the dump:
    Found one Java-level deadlock: ...

4. Logging with Context

Standard System.out.println is often not thread-safe or lacks context. Use a logging framework (like Logback, which is in your pom.xml) and include the thread name in your pattern:

<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>

5. Use Thread-Safe Decorators and Atomic Variables

Before reaching for synchronized blocks, see if you can use the java.util.concurrent utilities you already have in your project:

  • AtomicInteger / AtomicReference: For lock-free state updates (see your HighContentionCounter.java).
  • StampedLock: For high-performance optimistic reading (see StampedLockExample.java).
  • Semaphore: To throttle resource access and prevent starvation (see SemaphoreExample.java).

6. Stress Testing with jcrestress or Thread Interleaving

Sometimes code works 99% of the time. To find the 1% failure:

  1. Reduce Thread Sleep: Replace Thread.sleep() with CountDownLatch or Phaser to ensure threads hit a specific point at the same time.
  2. Looping: Wrap your test case in a loop that runs 10,000 times. Concurrency bugs often require specific CPU timing to trigger.

Pro-tip: If you suspect a race condition on a specific field, use a Field Watchpoint in IntelliJ. It will pause execution every time that specific variable is modified by any thread.

How do I create custom thread factories?

By Wayan in Concurrency, Util Package 0 Comment

Creating a custom thread factory in Java is a powerful way to manage how threads are initialized. Instead of using the default factory, you can customize thread names (vital for debugging!), set priority levels, or even create daemon threads.

To do this, you need to implement the java.util.concurrent.ThreadFactory interface.

1. Implement the ThreadFactory Interface

The interface has a single method: newThread(Runnable r). Here is a clean, reusable example:

package org.kodejava.util.concurrent;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

public class CustomThreadFactory implements ThreadFactory {
    private final String namePrefix;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final boolean daemon;

    public CustomThreadFactory(String poolName, boolean daemon) {
        this.namePrefix = poolName + "-worker-";
        this.daemon = daemon;
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r, namePrefix + threadNumber.getAndIncrement());
        t.setDaemon(daemon);
        t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

2. Use the Factory with an ExecutorService

Once you’ve defined your factory, you can pass it to any ThreadPoolExecutor or static Executors factory method. This ensures every thread created by that pool follows your rules.

package org.kodejava.util.concurrent;

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

public class ThreadFactoryDemo {
    public static void main(String[] args) {
        // Create the factory
        CustomThreadFactory factory = new CustomThreadFactory("OrderProcessor", false);

        // Pass it to a Fixed Thread Pool
        ExecutorService executor = Executors.newFixedThreadPool(3, factory);

        for (int i = 0; i < 5; i++) {
            executor.submit(() -> {
                System.out.println("Running task in: " + Thread.currentThread().getName());
            });
        }

        executor.shutdown();
    }
}

Why use a custom factory?

  • Identifiability: In thread dumps or logs, seeing OrderProcessor-worker-1 is much more helpful than pool-1-thread-1.
  • Security & Cleanup: You can set setDaemon(true) for background cleanup tasks so they don’t prevent the JVM from shutting down.
  • Context: You can use the factory to inject ThreadLocal variables or set a custom UncaughtExceptionHandler for all threads in a pool.

How do I use ExecutorService.invokeAll?

By Wayan in Concurrency, Util Package 0 Comment

Hello! ExecutorService.invokeAll is a powerful method when you have a collection of tasks and need to wait until every single one of them finishes before moving forward.

Here’s a breakdown of how it works and how to use it effectively.

What does invokeAll do?

  1. Executes a collection of tasks: It takes a Collection of Callable<T> objects.
  2. Blocks until completion: Unlike submit(), which returns immediately, invokeAll is blocking. It will not return until all tasks in the collection have completed (either normally or by throwing an exception).
  3. Returns a list of Futures: It returns a List<Future<T>> that holds the results (or exceptions) of the tasks, in the same order they were provided in the input collection.

Basic Usage Pattern

Here is a clean example of how to implement it:

package org.kodejava.util.concurrent;

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

public class InvokeAllDemo {
    public static void main(String[] args) {
        // 1. Create your ExecutorService
        try (ExecutorService executor = Executors.newFixedThreadPool(3)) {

            // 2. Define your tasks (Callable returns a value)
            List<Callable<String>> tasks = Arrays.asList(
                    () -> { Thread.sleep(500); return "Result A"; },
                    () -> { Thread.sleep(1000); return "Result B"; },
                    () -> { Thread.sleep(200); return "Result C"; }
            );

            try {
                // 3. Invoke all tasks. Execution stops here until all are done.
                System.out.println("Executing tasks...");
                List<Future<String>> futures = executor.invokeAll(tasks);

                // 4. Process the results
                for (Future<String> future : futures) {
                    // Future.get() will not block here because invokeAll already waited
                    System.out.println("Task output: " + future.get());
                }
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        } // Executor closes automatically with try-with-resources (Java 19+)
    }
}

Important Considerations

  • Order Preservation: The returned List<Future> maintains the same order as the input task list. futures.get(0) will always correspond to tasks.get(0).
  • Timeouts: There is an overloaded version: invokeAll(tasks, timeout, unit). If the timeout expires, tasks that haven’t finished are canceled, and the method returns the list of futures (some will be marked as canceled).
  • Exceptions: If a task throws an exception, invokeAll doesn’t fail. Instead, that specific Future.get() will throw an ExecutionException.
  • Blocking Behavior: Since invokeAll blocks the calling thread, avoid calling it on a thread that needs to stay responsive (like a UI thread or a primary event loop) without careful planning.

When to use it vs invokeAny?

  • Use invokeAll when you need the results of everything you started.
  • Use invokeAny when you have multiple ways to get a result, and you only care about the first one that finishes successfully (it cancels the rest).

Happy coding! If you’re working within a Spring environment, you might also want to look into @Async for higher-level abstraction, but for raw concurrency control, invokeAll is a classic choice.