Anvesh Srivastava
💻
In Java, this pattern is implemented using {@link java.util.concurrent.ForkJoinPool} and + * {@link java.util.concurrent.RecursiveTask}. Worker threads in the pool use a work-stealing + * algorithm — idle threads take tasks from busy threads — maximizing CPU utilization. + * + *
In this example, we demonstrate the pattern by computing the sum of a large array in parallel. + * The array is recursively split in half until each piece is small enough to sum directly, then + * results are combined back up. + */ +public final class App { + + private App() {} + + /** + * @param args command line arguments, not used + */ + public static void main(String[] args) { + // Create an array of 10 million numbers: [1, 2, 3, ..., 10_000_000] + long[] numbers = LongStream.rangeClosed(1, 10_000_000).toArray(); + + // Calculate sum using Fork/Join + ForkJoinSumCalculator calculator = new ForkJoinSumCalculator(); + long startTime = System.currentTimeMillis(); + long result = calculator.calculateSum(numbers); + long endTime = System.currentTimeMillis(); + + // The expected sum of 1 to N is N*(N+1)/2 + long expected = 10_000_000L * 10_000_001L / 2; + + System.out.println("Fork/Join sum: " + result); + System.out.println("Expected sum: " + expected); + System.out.println("Correct: " + (result == expected)); + System.out.println("Time taken: " + (endTime - startTime) + " ms"); + System.out.println("Available processors: " + Runtime.getRuntime().availableProcessors()); + } +} diff --git a/fork-join/src/main/java/com/iluwatar/forkjoin/ForkJoinSumCalculator.java b/fork-join/src/main/java/com/iluwatar/forkjoin/ForkJoinSumCalculator.java new file mode 100644 index 000000000000..0e9dff32cda8 --- /dev/null +++ b/fork-join/src/main/java/com/iluwatar/forkjoin/ForkJoinSumCalculator.java @@ -0,0 +1,44 @@ +package com.iluwatar.forkjoin; + +import java.util.concurrent.ForkJoinPool; + +/** + * ForkJoinSumCalculator provides a convenient API to sum an array of numbers using the Fork/Join + * framework. It creates a {@link ForkJoinPool}, submits a {@link SumTask}, and returns the computed + * sum. + * + *
The pool manages a set of worker threads that process subtasks in parallel. Idle threads can + * "steal" work from busy threads, maximizing CPU utilization. + */ +public class ForkJoinSumCalculator { + + private final ForkJoinPool pool; + + /** Creates a calculator using the common ForkJoinPool (uses all available CPU cores). */ + public ForkJoinSumCalculator() { + this.pool = ForkJoinPool.commonPool(); + } + + /** + * Creates a calculator with a specific number of threads. + * + * @param parallelism the number of worker threads to use + */ + public ForkJoinSumCalculator(int parallelism) { + this.pool = new ForkJoinPool(parallelism); + } + + /** + * Calculates the sum of all elements in the array using Fork/Join parallelism. + * + * @param numbers the array of numbers to sum + * @return the total sum of all elements + */ + public long calculateSum(long[] numbers) { + if (numbers == null || numbers.length == 0) { + return 0; + } + SumTask task = new SumTask(numbers, 0, numbers.length); + return pool.invoke(task); + } +} diff --git a/fork-join/src/main/java/com/iluwatar/forkjoin/SumTask.java b/fork-join/src/main/java/com/iluwatar/forkjoin/SumTask.java new file mode 100644 index 000000000000..acbd5f0516b7 --- /dev/null +++ b/fork-join/src/main/java/com/iluwatar/forkjoin/SumTask.java @@ -0,0 +1,93 @@ +package com.iluwatar.forkjoin; + +import java.util.concurrent.RecursiveTask; + +/** + * SumTask demonstrates the Fork/Join pattern by recursively splitting an array summation problem + * into smaller subtasks until each subtask is small enough to compute directly. + * + *
How it works: If the portion of the array is smaller than THRESHOLD, sum it in a simple loop.
+ * Otherwise, split the array in half, fork one half to run in parallel, compute the other half in
+ * the current thread, and then join the results. This approach utilizes multiple CPU cores to
+ * perform the summation significantly faster than a single-threaded loop for large arrays.
+ */
+public class SumTask extends RecursiveTask The WAL pattern guarantees durability by ensuring every mutation (SET, DELETE) is written to a
+ * persistent append-only log file on disk BEFORE updating in-memory state. If the system crashes
+ * unexpectedly, replaying log entries from the WAL file restores state.
+ */
+@Slf4j
+public class App {
+
+ /**
+ * Application entry point.
+ *
+ * @param args command line arguments
+ */
+ public static void main(String[] args) {
+ try {
+ File logFile = File.createTempFile("wal_demo", ".log");
+ logFile.deleteOnExit();
+
+ LOGGER.info(
+ "=== 1. Initializing Storage Engine with WAL at {} ===", logFile.getAbsolutePath());
+ WriteAheadLog wal = new WriteAheadLog(logFile);
+ DatabaseStore store = new DatabaseStore(wal);
+
+ LOGGER.info("=== 2. Performing Data Operations (Write-Ahead Logging) ===");
+ store.put("user:101", "Alice");
+ store.put("user:102", "Bob");
+ store.put("user:103", "Charlie");
+ store.put("user:102", "Bob Smith");
+ store.delete("user:103");
+ store.checkpoint();
+
+ LOGGER.info("MemTable snapshot before crash: {}", store.getMemTableSnapshot());
+
+ LOGGER.info("=== 3. Simulating Unexpected System Crash ===");
+ store.simulateCrash();
+ LOGGER.info("MemTable snapshot after crash: {}", store.getMemTableSnapshot());
+
+ LOGGER.info("=== 4. System Restart & Recovery from WAL ===");
+ store.recover();
+ LOGGER.info("MemTable snapshot post recovery: {}", store.getMemTableSnapshot());
+
+ if (logFile.exists()) {
+ logFile.delete();
+ }
+ } catch (IOException e) {
+ LOGGER.error("An error occurred during WAL demonstration: {}", e.getMessage(), e);
+ }
+ }
+}
diff --git a/write-ahead-log/src/main/java/com/iluwatar/writeaheadlog/DatabaseStore.java b/write-ahead-log/src/main/java/com/iluwatar/writeaheadlog/DatabaseStore.java
new file mode 100644
index 000000000000..dd6d94fce7aa
--- /dev/null
+++ b/write-ahead-log/src/main/java/com/iluwatar/writeaheadlog/DatabaseStore.java
@@ -0,0 +1,131 @@
+/*
+ * This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+ *
+ * The MIT License
+ * Copyright © 2014-2022 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.iluwatar.writeaheadlog;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Storage engine demonstrating Write-Ahead Log (WAL) pattern. All mutations are logged and flushed
+ * to persistent WAL storage before modifying the in-memory MemTable.
+ */
+@Slf4j
+public class DatabaseStore {
+
+ @Getter private final WriteAheadLog wal;
+ private final Map