Add Multithreading (part I) and Network Programming (part II) code snippets

Author: 100yo

10-network/snippets/README.md

@@ -0,0 +1 @@
+# Многонишково програмиране (част II) и Мрежово програмиране (част I) / Code snippets

10-network/snippets/src/network/InetAddressExample.java

@@ -0,0 +1,20 @@
+void main() throws IOException {
+
+    InetAddress address = InetAddress.getByName("www.google.com");
+    IO.println(address.getHostAddress()); // 172.217.17.132
+
+    address = InetAddress.getByName("62.44.101.151");
+    IO.println(address.getHostName()); // learn.fmi.uni-sofia.bg
+
+    IO.println(address.isReachable(5_000)); // true
+
+    InetAddress localhost = InetAddress.getLocalHost();
+    IO.println(localhost.getHostAddress()); // IP associated with your hostname,
+                                            // typically LAN IP (192.168.x.x)
+
+    // Think of:
+    //   - LAN IP = your apartment number
+    //   - Public IP = the street address for the whole building
+    //   - 127.0.0.1 = your own room inside your apartment (only you can reach it)
+
+}

10-network/snippets/src/network/LanIpFinder.java

@@ -0,0 +1,28 @@
+void main() throws Exception {
+    InetAddress lanIp = getLanIp();
+    IO.println(lanIp);
+}
+
+public static InetAddress getLanIp() throws SocketException {
+    Enumeration<NetworkInterface> nics = NetworkInterface.getNetworkInterfaces();
+
+    while (nics.hasMoreElements()) {
+        NetworkInterface nic = nics.nextElement();
+
+        // Skip loopback, down, or virtual interfaces
+        if (!nic.isUp() || nic.isLoopback() || nic.isVirtual()) {
+            continue;
+        }
+
+        Enumeration<InetAddress> addrs = nic.getInetAddresses();
+        while (addrs.hasMoreElements()) {
+            InetAddress addr = addrs.nextElement();
+
+            // We want only IPv4 addresses and exclude loopback
+            if (addr instanceof Inet4Address && !addr.isLoopbackAddress()) {
+                return addr;
+            }
+        }
+    }
+    return null; // or throw exception if required
+}

10-network/snippets/src/network/NetworkInterfacesLister.java

@@ -0,0 +1,37 @@
+void main() throws Exception {
+
+    Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
+
+    while (interfaces.hasMoreElements()) {
+        NetworkInterface nic = interfaces.nextElement();
+
+        IO.println("----------------------------------------------------");
+        IO.println("Name         : " + nic.getName());
+        IO.println("Up           : " + nic.isUp());
+        IO.println("Loopback     : " + nic.isLoopback());
+        IO.println("Virtual      : " + nic.isVirtual());
+        IO.println("PointToPoint : " + nic.isPointToPoint());
+        IO.println("MTU          : " + nic.getMTU());
+
+        byte[] mac = nic.getHardwareAddress();
+        IO.print("MAC Address  : ");
+        if (mac != null) {
+            for (int i = 0; i < mac.length; i++) {
+                System.out.printf("%02X%s", mac[i], (i < mac.length - 1) ? "-" : "");
+            }
+            IO.println();
+        } else {
+            IO.println("N/A");
+        }
+
+        // List all IPv4/IPv6 addresses
+        IO.println("IP Addresses :");
+        Enumeration<InetAddress> addrs = nic.getInetAddresses();
+        while (addrs.hasMoreElements()) {
+            InetAddress addr = addrs.nextElement();
+            IO.println("   - " + addr.getHostAddress());
+        }
+        IO.println();
+    }
+
+}

10-network/snippets/src/structuredconcurrency/StructuredConcurrencyDemo.java

@@ -0,0 +1,47 @@
+/*
+ * Structured Concurrency Example in Java 25
+ *
+ * This example demonstrates Java's StructuredTaskScope, a preview feature in Java 25.
+ * Structured concurrency allows you to fork multiple tasks within a scope, wait for all
+ * of them to complete, and handle exceptions in a structured way.
+ *
+ * Key points:
+ * 1. Tasks are forked concurrently using scope.fork().
+ * 2. scope.join() waits for all tasks to finish and throws FailedException if any task fails.
+ * 3. Results are retrieved using subtask.get() after join().
+ * 4. Any running tasks are automatically cancelled if one fails.
+ *
+ * This makes concurrent code easier to read, safer, and less error-prone than manual thread management.
+ */
+
+void main() {
+    // Open a structured task scope
+    try (var scope = StructuredTaskScope.<String>open()) {
+
+        // Fork tasks concurrently
+        var task1 = scope.fork(() -> work("Task 1", 1000));
+        var task2 = scope.fork(() -> work("Task 2 (fails)", 500));
+        var task3 = scope.fork(() -> work("Task 3", 800));
+
+        // Wait for all tasks to complete; throws FailedException if any task failed
+        scope.join();
+
+        // Retrieve results using get() after join() succeeds
+        IO.println(task1.get());
+        IO.println(task2.get());
+        IO.println(task3.get());
+
+    } catch (StructuredTaskScope.FailedException e) {
+        IO.println("One or more tasks failed: " + e.getCause());
+    } catch (InterruptedException e) {
+        IO.println("Interrupted while waiting for tasks.");
+    }
+}
+
+private static String work(String name, int delayMillis) throws Exception {
+    Thread.sleep(delayMillis);
+    if (name.contains("fails")) {
+        throw new RuntimeException(name + " encountered an error!");
+    }
+    return name + " completed successfully";
+}

10-network/snippets/src/threadpools/CachedThreadPoolExample.java

@@ -0,0 +1,28 @@
+package threadpools;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class CachedThreadPoolExample {
+
+    // A cached thread pool will reuse available threads, but if all threads are busy
+    // and more tasks are submitted, it will create new threads.
+    // If a thread is idle for 60s, it will be decommissioned.
+
+    private static final int MAX_TASKS = 15;
+
+    static void main() {
+
+        // Creates a thread pool with a fixed number of threads
+        ExecutorService executor = Executors.newCachedThreadPool();
+
+        // Submit tasks to the executor.
+        for (int i = 0; i < MAX_TASKS; i++) {
+            Runnable task = new Task("" + i);
+            executor.execute(task); // Execute the task using the thread pool.
+        }
+
+        // Shutdown the executor service. It will not accept new tasks but complete existing ones.
+        executor.shutdown();
+    }
+}

10-network/snippets/src/threadpools/FixedThreadPoolExample.java

@@ -0,0 +1,28 @@
+package threadpools;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class FixedThreadPoolExample {
+
+    // A fixed thread pool contains a specified number of threads. If all threads are busy
+    // and additional tasks are submitted, they will wait in the queue until a thread is available.
+
+    private static final int MAX_THREADS = 3;
+    private static final int MAX_TASKS = 15;
+
+    static void main() {
+
+        // Creates a thread pool with a fixed number of threads
+        ExecutorService executor = Executors.newFixedThreadPool(MAX_THREADS);
+
+        // Submit tasks to the executor.
+        for (int i = 0; i < MAX_TASKS; i++) {
+            Runnable task = new Task("" + i);
+            executor.execute(task); // Execute the task using the thread pool.
+        }
+
+        // Shutdown the executor service. It will not accept new tasks but complete existing ones.
+        executor.shutdown();
+    }
+}

10-network/snippets/src/threadpools/ScheduledThreadPoolExample.java

@@ -0,0 +1,48 @@
+package threadpools;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+public class ScheduledThreadPoolExample {
+
+    // A scheduled thread pool is used for scheduling tasks
+    // to execute after a delay or to execute periodically.
+
+    static void main() throws InterruptedException {
+
+        // Creates a scheduled thread pool with 2 threads.
+        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(10);
+
+        // Schedule tasks
+        scheduler.schedule(() -> System.out.println("Delayed task executed after 5 seconds"), 5, TimeUnit.SECONDS);
+
+        // Schedule a task to repeat at a fixed rate.
+        // The interval is based on the scheduled start time of each execution, maintaining a strict execution schedule
+        // which may lead to task overlap if execution time exceeds the scheduled rate.
+        scheduler.scheduleAtFixedRate(() -> {
+            doSomeWork(2_000);
+            System.out.println("Some regular task executed at fixed rate by " + Thread.currentThread().getName());
+        }, 0, 1, TimeUnit.SECONDS);
+
+        // Schedule a task to repeat with a fixed delay based on the actual completion time of the previous execution,
+        // providing buffer time if the task takes longer, preventing task overlap.
+        scheduler.scheduleWithFixedDelay(() -> {
+            doSomeWork(2_000);
+            System.out.println("Some regular task executed with fixed delay by " + Thread.currentThread().getName());
+        }, 0, 1, TimeUnit.SECONDS);
+
+        // Shut down the scheduler after some delay to allow time for tasks to execute.
+        scheduler.schedule(() -> scheduler.shutdown(), 20, TimeUnit.SECONDS);
+
+    }
+
+    private static void doSomeWork(long millis) {
+        try {
+            Thread.sleep(millis);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+}

10-network/snippets/src/threadpools/Task.java

@@ -0,0 +1,20 @@
+package threadpools;
+
+public class Task implements Runnable {
+    private final String taskId;
+
+    public Task(String id) {
+        this.taskId = id;
+    }
+
+    @Override
+    public void run() {
+        System.out.println("Executing Task Id: " + taskId + ", by " + Thread.currentThread().getName());
+        try {
+            Thread.sleep(1_000); // Simulate some work with a sleep.
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

10-network/snippets/src/threadpools/VirtualThreadPoolExample.java

@@ -0,0 +1,37 @@
+package threadpools;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class VirtualThreadPoolExample {
+
+    static void main() {
+
+        // Create an executor service using a new virtual threads for every new task
+        ExecutorService executorService = Executors.newVirtualThreadPerTaskExecutor();
+
+        try (executorService) {
+
+            // Submit several tasks to the executor
+            for (int i = 0; i < 10; i++) {
+
+                final int taskId = i;
+
+                executorService.submit(() -> {
+                    // Note that virtual threads are created without a name by default to minimize overhead
+                    // and because the high number of threads typically makes naming them impractical.
+                    System.out.println("Running task " + taskId + " in " + Thread.currentThread());
+
+                    // Simulate some work with sleep
+                    try {
+                        Thread.sleep(1_000);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                });
+            }
+
+        } // executorService will be autoclosed --> auto shut down
+
+    }
+}