Extremely Serious

Month: March 2024

Demystifying Virtual Threads

Java 21 introduces a game-changer for concurrent programming: virtual threads. This article explores what virtual threads are and how they can revolutionize the way you build high-performance applications.

Traditional Threads vs. Virtual Threads

Java developers have long relied on platform threads, the fundamental unit of processing that runs concurrently. However, creating and managing a large number of platform threads can be resource-intensive. This becomes a bottleneck for applications handling high volumes of requests.

Virtual threads offer a lightweight alternative. They are managed by the Java runtime environment, allowing for a much larger number to coexist within a single process compared to platform threads. This translates to significant benefits:

  • Reduced Overhead: Creating and managing virtual threads requires fewer resources, making them ideal for applications that thrive on high concurrency.
  • Efficient Hardware Utilization: Virtual threads don't directly map to operating system threads, enabling them to better leverage available hardware cores. This translates to handling more concurrent requests and improved application throughput.
  • Simpler Concurrency Model: Virtual threads adhere to the familiar "one thread per request" approach used with platform threads. This makes the transition for developers already comfortable with traditional concurrency patterns much smoother. There's no need to learn entirely new paradigms or complex APIs.

Creating Virtual Threads

Java 21 offers two primary ways to create virtual threads:

  1. Thread.Builder Interface: This approach provides a familiar interface for creating virtual threads. You can use a static builder method or a builder object to configure properties like thread name before starting it.

    Here's an example of using the Thread.Builder interface:

    Runnable runnable = () -> {
       var name = Thread.currentThread().getName();
       System.out.printf("Hello, %s!%n", name.isEmpty() ? "anonymous" : name);
    try {
       // Using a static builder method
       Thread virtualThread = Thread.startVirtualThread(runnable);
       // Using a builder with a custom name
       Thread namedThread = Thread.ofVirtual()
       // Wait for the threads to finish (optional)
    } catch (InterruptedException e) {
       throw new RuntimeException(e);
  2. ExecutorService with Virtual Threads: This method leverages an ExecutorService specifically designed to create virtual threads for each submitted task. This approach simplifies thread management and ensures proper cleanup of resources.

    Here's an example of using an ExecutorService with virtual threads:

    try (ExecutorService myExecutor = Executors.newVirtualThreadPerTaskExecutor()) {
       Future future = myExecutor.submit(() -> System.out.println("Running thread"));
       future.get(); // Wait for the task to complete
       System.out.println("Task completed");
    } catch (ExecutionException | InterruptedException e) {
       throw new RuntimeException(e);

Embrace a New Era of Concurrency

Virtual threads represent a significant leap forward in Java concurrency. Their efficiency, better hardware utilization, and familiar approach make them a powerful tool for building high-performance and scalable applications.

Demystifying Switch Type Patterns

Instead of simply matching against constant values, switch type patterns allow you to match against the types and their specific characteristics of the evaluated expression. This translates to cleaner, more readable code compared to traditional if-else statements or cumbersome instanceof checks.

Key Features

  • Type patterns: These match against the exact type of the evaluated expression (e.g., case String s).
  • Deconstruction patterns: These extract specific elements from record objects of a certain type (e.g., case Point(int x, int y)).
  • Guarded patterns: These add additional conditions to be met alongside the type pattern, utilizing the when clause (e.g., case String s when s.length() > 5).
  • Null handling: You can now explicitly handle the null case within the switch statement.


  • Enhanced Readability: Code becomes more intuitive by directly matching against types and extracting relevant information.
  • Reduced Boilerplate: Eliminate the need for extensive instanceof checks and type casting, leading to cleaner code.
  • Improved Type Safety: Explicit type checks within the switch statement prevent potential runtime errors.
  • Fine-grained Control Flow: The when clause enables precise matching based on both type and additional conditions.

Examples in Action

  1. Type Patterns:

    Number number = 10l;
    switch (number) {
       case Integer i -> System.out.printf("%d is an integer!", i);
       case Long l -> System.out.printf("%d is a long!", l);
       default -> System.out.println("Unknown type");

    In this example, the switch statement checks the exact type of number using the Long type pattern.

  2. Deconstruction Patterns:

    record Point(int x, int y) {}
    Point point = new Point(2, 3);
    switch (point) {
       case Point(var x, var y) -> System.out.println("Point coordinates: (" + x + ", " + y + ")");
       default -> System.out.println("Unknown object type");

    Here, the deconstruction pattern extracts the x and y coordinates from the Point record object and assigns them to variables within the case block.

  3. Guarded Patterns with the when Clause:

    String name = "John Doe";
    switch (name) {
       case String s when s.length() > 5 -> System.out.println("Long name!");
       case String s -> System.out.println("It's a string.");

    This example demonstrates a guarded pattern. The first case checks if the evaluated expression is a String and its length is greater than 5 using the when clause.

  4. Null Handling:

    Object object = null;
    switch (object) {
     case null -> System.out.println("The object is null.");
     case String s -> System.out.println("It's a string!");
     default -> System.out.println("Unknown object type");

    Finally, this example showcases the ability to explicitly handle the null case within the switch statement, improving code safety.


Switch type patterns in Java 21 offer a powerful and versatile way to write concise, readable, and type-safe code. By leveraging its features, including the when clause for guarded patterns, you can significantly enhance the maintainability and expressiveness of your Java applications.

Understanding Sequenced Collections

Java 21 introduced a significant enhancement to the collection framework: SequencedCollection. This new interface brings order to the world of collections, providing standardized ways to interact with elements based on their sequence.

What are Sequenced Collections?

Imagine a list where the order of elements matters. That's the essence of a SequencedCollection. It extends the existing Collection interface, offering additional functionalities specific to ordered collections.

Key Features:

  • Accessing first and last elements: Methods like getFirst() and getLast() grant direct access to the first and last elements in the collection, respectively.
  • Adding and removing elements at ends: Efficiently manipulate the beginning and end of the sequence with methods like addFirst(), addLast(), removeFirst(), and removeLast().
  • Reversed view: The reversed() method provides a view of the collection in reverse order. Any changes made to the original collection are reflected in the reversed view.


  • Simplified code: SequencedCollection provides clear and concise methods for working with ordered collections, making code easier to read and maintain.
  • Improved readability: The intent of operations becomes more evident when using methods like addFirst() and removeLast(), leading to better understanding of code.

Example Usage:

Consider a Deque (double-ended queue) implemented using ArrayDeque:

import java.util.ArrayDeque;
import java.util.Deque;

public class SequencedCollectionExample {
    public static void main(String ... args) {
        Deque<String> tasks = new ArrayDeque<>();

        // Add tasks (FIFO order)
        tasks.addLast("Buy groceries");
        tasks.addLast("Finish homework");
        tasks.addLast("Call mom");

        // Access and process elements
        System.out.println("First task: " + tasks.getFirst());

        // Process elements in reverse order
        Deque<String> reversedTasks = tasks.reversed();
        for (String task : reversedTasks) {
            System.out.println("Reversed: " + task);

This example demonstrates how SequencedCollection allows for efficient access and manipulation of elements based on their order, both forward and backward.

Implementation Classes:

While SequencedCollection is an interface, existing collection classes automatically become SequencedCollection by virtue of inheriting from Collection. Here's a brief overview:

  • Lists: ArrayList, LinkedList, and Vector
  • Sets: Not directly applicable, but LinkedHashSet maintains order within sets.
  • Queues: ArrayDeque and LinkedList
  • Maps: Not directly applicable, but LinkedHashMap and TreeMap (based on key order) maintain order for key-value pairs.

Remember, specific functionalities and behaviors might vary within these classes. Refer to the official Java documentation for detailed information.


SequencedCollection is a valuable addition to the Java collection framework, offering a structured and efficient way to work with ordered collections. By understanding its features and functionalities, you can write more readable, maintainable, and expressive code when dealing with ordered data structures in Java 21 and beyond.

Understanding Semaphores in Java for Concurrent Programming

In the realm of concurrent programming, managing shared resources among multiple threads is a critical challenge. To address this, synchronization primitives like semaphores play a pivotal role. In Java, the Semaphore class offers a powerful toolset for controlling access to shared resources.

What is a Semaphore?

A semaphore is a synchronization mechanism that regulates access to shared resources by controlling the number of threads that can access them concurrently. It maintains a set of permits, where each thread must acquire a permit before accessing the shared resource. The number of available permits dictates the level of concurrency allowed.

Java's Semaphore Class

In Java, the Semaphore class resides in the java.util.concurrent package and provides methods to acquire and release permits. Let's explore a simple example to grasp the concept:

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(2); // Initializes with 2 permits

        Runnable task = () -> {
            try {
                semaphore.acquire(); // Acquire a permit
                // Critical section: access shared resource
                System.out.println(Thread.currentThread().getName() + " is accessing the shared resource.");
                Thread.sleep(2000); // Simulating some work
            } catch (InterruptedException e) {
            } finally {
                semaphore.release(); // Release the permit

        // Create and start multiple threads
        for (int i = 0; i < 5; i++) {
            new Thread(task).start();

In this example, the semaphore with two permits ensures that only two threads can access the shared resource concurrently. The acquire() and release() methods facilitate controlled access to the critical section.

Use Cases for Semaphores

Semaphores are particularly useful in scenarios where limited resources need to be shared among multiple threads. Some common use cases include:

  1. Thread Pool Management: Semaphores can regulate the number of threads active in a pool, preventing resource exhaustion.
  2. Database Connection Pools: Controlling access to a limited number of database connections to avoid overwhelming the system.
  3. Printers and I/O Devices: Managing concurrent access to printers or other I/O devices to prevent conflicts.
  4. Producer-Consumer Problem: Coordinating the interaction between producers and consumers to avoid race conditions.

In conclusion, semaphores in Java provide a robust mechanism for coordinating access to shared resources in a concurrent environment. Understanding their operations and use cases is crucial for building scalable and efficient multi-threaded applications.

Exploring Java’s Fork-Join Framework: Parallelism Made Efficient

Java's Fork-Join Framework, introduced in Java 7 as part of the java.util.concurrent package, offers a powerful mechanism for parallelizing and efficiently handling divide-and-conquer-style algorithms. At its core is the ForkJoinPool, a sophisticated executor service designed for managing parallel tasks.

Overview of Fork-Join Framework

The Fork-Join Framework is particularly well-suited for recursive and divide-and-conquer algorithms. It provides two main classes: RecursiveTask for tasks that return a result, and RecursiveAction for tasks that perform an action without returning a result.

ForkJoinPool and Parallelism

The ForkJoinPool manages a set of worker threads and facilitates the parallel execution of tasks. The default pool size is dynamically determined based on the available processors on the machine. This adaptive sizing allows for efficient resource utilization.

// Creating a ForkJoinPool with default parallelism
ForkJoinPool forkJoinPool = new ForkJoinPool();

Limiting the Size of the Pool

It is possible to limit the size of the ForkJoinPool by specifying the parallelism level during its creation. This can be useful to control resource usage and adapt the pool to specific requirements.

// Creating a ForkJoinPool with a limited parallelism level
int parallelismLevel = 4;
ForkJoinPool limitedPool = new ForkJoinPool(parallelismLevel);

Work-Stealing Strategy

The heart of the Fork-Join Framework's efficiency lies in its work-stealing strategy. Here's a breakdown of how it works:

  • Task Splitting: Tasks can recursively split into smaller subtasks during execution.
  • Deque Structure: Each worker thread has its own deque (double-ended queue) for storing tasks.
  • Stealing Tasks: When a worker thread's deque is empty, it steals tasks from other worker threads' deques, minimizing contention.
  • Load Balancing: The strategy ensures efficient load balancing by redistributing tasks among available threads.
  • Task Affinity: Threads tend to execute tasks they have recently created or stolen, optimizing cache usage.

Handling Blocking Situations

If all worker threads are blocked, for instance, due to tasks waiting on external resources, the pool can become stalled. In such cases, the efficiency of the Fork-Join Pool might be compromised. It's crucial to be mindful of blocking operations within tasks and consider alternative concurrency mechanisms if needed.

6. Managing the Pool's Lifecycle

Once a ForkJoinPool is created, it should be explicitly shut down when no longer needed to prevent resource leaks and ensure a clean application exit.

// Shutting down the ForkJoinPool

7. Sample Usage

Let's consider a simple example of calculating the sum of an array using a Fork-Join task:

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

public class SumTask extends RecursiveTask<Integer> {
    private final int[] data;
    private final int start;
    private final int end;

    public SumTask(int[] data, int start, int end) {
        this.data = data;
        this.start = start;
        this.end = end;

    protected Integer compute() {
        if (end - start <= 10) {
            // Solve the problem sequentially
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += data[i];
            return sum;
        } else {
            // Split the task into subtasks
            int mid = (start + end) / 2;
            SumTask leftTask = new SumTask(data, start, mid);
            SumTask rightTask = new SumTask(data, mid, end);

            // Fork the subtasks

            // Join the results
            int leftResult = leftTask.join();
            int rightResult = rightTask.join();

            // Combine the results
            return leftResult + rightResult;

    public static void main(String[] args) {
        int[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        int result = forkJoinPool.invoke(new SumTask(data, 0, data.length));
        System.out.println("Result: " + result);

        // Don't forget to shut down the pool when it's no longer needed

In this example, we use a ForkJoinPool to calculate the sum of an array efficiently by dividing the task into subtasks and utilizing the work-stealing strategy.

Exploring ArrayBlockingQueue in Java

Java provides a variety of concurrent data structures to facilitate communication and synchronization between threads. One such class is ArrayBlockingQueue, which is a blocking queue implementation backed by an array. This queue is particularly useful in scenarios where multiple threads need to exchange data in a producer-consumer fashion.


To use ArrayBlockingQueue, start by importing the necessary class:

import java.util.concurrent.ArrayBlockingQueue;

Then, initialize the queue with a specified capacity:

ArrayBlockingQueue<Type> queue = new ArrayBlockingQueue<>(capacity);

Replace Type with the type of elements you want to store, and capacity with the maximum number of elements the queue can hold.

Adding and Removing Elements

Adding Elements

  • put(element): Adds an element to the queue. Blocks if the queue is full.
  • offer(element): Adds an element to the queue if space is available, returns true if successful, false otherwise.
  • offer(element, timeout, timeUnit): Adds an element to the queue, waiting for the specified time if necessary for space to be available.

Removing Elements

  • take(): Removes and returns the head of the queue. Blocks if the queue is empty.
  • poll(): Removes and returns the head of the queue, or returns null if the queue is empty.
  • poll(timeout, timeUnit): Removes and returns the head of the queue, waiting for the specified time if the queue is empty.

Example Usage: Producer-Consumer Scenario

Consider a simple example where a producer thread produces messages, and a consumer thread consumes them using ArrayBlockingQueue:

import java.util.concurrent.ArrayBlockingQueue;

public class ProducerConsumerExample {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(5);

        // Producer thread
        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    String message = "Message " + i;
                    System.out.println("Produced: " + message);
            } catch (InterruptedException e) {

        // Consumer thread
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    String message = queue.take();
                    System.out.println("Consumed: " + message);
            } catch (InterruptedException e) {


In this example, the producer and consumer threads interact through the ArrayBlockingQueue, ensuring a smooth exchange of messages while handling blocking situations when the queue is full or empty.

ArrayBlockingQueue serves as a valuable tool in concurrent programming, providing a simple yet effective means of communication and synchronization between threads in Java.

Understanding the $_ Variable in PowerShell

PowerShell, a versatile scripting language for Windows environments, introduces the $_ (underscore) variable, a fundamental component in the pipeline operation. This variable is used to reference the current object being processed, particularly within cmdlets that operate on objects in a pipeline. See the following sample usages:

ForEach-Object: Iterating through Objects

The ForEach-Object cmdlet allows the iteration through a collection of objects. The $_ variable is employed to reference the current object within the script block.

$numbers = 1, 2, 3, 4, 5

$numbers | ForEach-Object {
    "Current value is: $_"

In this example, $_ represents each number in the array during the iteration.

Where-Object: Filtering Objects

With Where-Object, you can filter objects based on specified criteria. The $_ variable is used to reference the current object within the script block defining the filtering condition.

$numbers = 1, 2, 3, 4, 5
$numbers | Where-Object { $_ -gt 2 }

Here, $_ is employed to compare each number in the array and filter those greater than 2.

Select-Object: Customizing Object Output

Select-Object is utilized for customizing the output of selected properties. The $_ variable is used to reference the current object's properties.

Get-Process | Select-Object Name, @{Name='Memory (MB)'; Expression={$_.WorkingSet / 1MB}}

In this example, $_ enables the selection and manipulation of properties for each process in the pipeline.

Sort-Object: Sorting Objects

Sorting objects with Sort-Object involves specifying a script block. The $_ variable is used to reference the current object for sorting.

Get-Service | Sort-Object {$_.Status}

Here, $_ is utilized to determine the sorting order based on the Status property of each service.

Group-Object: Grouping Objects

Group-Object groups objects based on a specified property. The $_ variable is essential for referencing the current object during the grouping process.

Get-Process | Group-Object {$_.PriorityClass}

In this instance, $_ plays a key role in grouping processes based on their PriorityClass property.

Understanding and effectively utilizing the $_ variable empowers PowerShell users to manipulate objects within the pipeline, providing flexibility and control over script operations.

Batch Scripting: Including Scripts and Managing Environment Variables

Batch scripting is a powerful tool for automating tasks in Windows environments. One useful feature is the ability to include one script within another, allowing for modular and reusable code. Let's explore how to include scripts and manage environment variables in batch scripting.

Including Scripts with the call Command

The call command is used to include one batch script into another. This feature facilitates code organization and reusability. For example, let's create two batch scripts, "script1.bat" and "script2.bat".


@echo off
set MY_VARIABLE=Hello from script1
call script2.bat
echo In script1, MY_VARIABLE is: %MY_VARIABLE%


@echo off
echo In script2, MY_VARIABLE is: %MY_VARIABLE%
set MY_VARIABLE=Hello from script2

In this example, script1.bat sets the MY_VARIABLE environment variable and then calls script2.bat using the call command. The output demonstrates that changes to the environment variable made in script2.bat are reflected in script1.bat.

In script2, MY_VARIABLE is: Hello from script1
In script1, MY_VARIABLE is: Hello from script2

Managing Environment Variables Across Scripts

When a script is called from another script using call, any changes made to environment variables in the called script persist in the calling script. This behavior allows for the sharing of variables between scripts.

It's important to note that this method of managing environment variables creates a shared scope between the calling and called scripts. This can be advantageous for passing information between scripts or modularizing code.

Best Practices for Environment Variables

  1. Clear Naming Conventions: Use clear and consistent naming conventions for your environment variables to avoid confusion and potential conflicts.
  2. Document Your Variables: Include comments in your scripts to document the purpose and usage of environment variables. This helps other developers (or even yourself in the future) understand the code.
  3. Avoid Global Variables if Unnecessary: While sharing environment variables between scripts is powerful, it's advisable to avoid excessive use of global variables to maintain script independence and reduce potential issues.
  4. Error Handling: Implement robust error handling to gracefully handle situations where a variable might not be set as expected.


Batch scripting provides a straightforward way to automate tasks in Windows environments. The ability to include scripts and manage environment variables enhances the flexibility and modularity of batch scripts. By following best practices, you can create well-organized and maintainable scripts that efficiently perform complex tasks.

Remember to experiment with these concepts in your own scripts and adapt them based on your specific requirements. Happy scripting!

Understanding setlocal in Batch Scripting

Batch scripting is a powerful tool for automating tasks in Windows environments. Within these scripts, the setlocal command plays a crucial role in managing environment variables and their scope.

What is setlocal?

setlocal is a command in batch scripting that initiates the localization of environment changes. Its primary purpose is to restrict the scope of environment variable modifications to the current batch script or the calling environment of that script. By doing so, it ensures that any alterations made to environment variables during script execution are temporary and do not affect the broader system.

How Does setlocal Work?

Consider the following example:

@echo off
echo Before setlocal: %MY_VARIABLE%

set MY_VARIABLE=LocalValue
echo Inside setlocal: %MY_VARIABLE%

echo After endlocal: %MY_VARIABLE%

In this script:

  1. Initially, the %MY_VARIABLE% is echoed, displaying its value before setlocal.
  2. setlocal is then used to initiate localization, creating a localized environment.
  3. Within this localized environment, MY_VARIABLE is set to "LocalValue."
  4. After the endlocal command, the script returns to the global environment, and the value of %MY_VARIABLE% reverts to its original state.

Use Cases for setlocal

The setlocal command is particularly useful in scenarios where you want to make temporary changes to environment variables without affecting the broader system settings. It is commonly employed when writing batch scripts that need to modify variables for specific tasks, ensuring that these modifications are isolated to the script's execution.

Example Use Case:

Suppose you have a batch script that requires a specific configuration or path during execution. Using setlocal, you can modify environment variables to meet the script's requirements without impacting the overall system configuration. Once the script completes, the changes are automatically rolled back with the use of endlocal.


Understanding and using setlocal in batch scripting is essential for managing environment variables effectively. By localizing changes, you can ensure that modifications made during script execution are temporary and do not have unintended consequences on the broader system. This command provides a level of control and isolation that is crucial for writing robust and predictable batch scripts.

In summary, setlocal is a valuable tool for scriptwriters, enabling them to make temporary environment variable changes in a controlled manner, ensuring the integrity of the broader system environment.