Executor Framework

In concurrent programming, separating the management of threads from the business logic of tasks creates more maintainable and scalable applications. The java.util.concurrent package provides the Executor framework to handle this decoupling. Instead of explicitly creating threads using new Thread(runnable).start(), developers can delegate task execution to executor objects.

Executor Interfaces

The framework defines three primary interfaces:

• Executor: A simple interface with an execute(Runnable) method. It abstracts the thread creation process.
• ExecutorService: Extends Executor, adding lifecycle management (shutdown) and the ability to submit Callable tasks that return results via Future objects.
• ScheduledExecutorService: Extends ExecutorService to support delayed and periodic task execution.

Thread Pools

Thread pools are the most common implementation of executors. They manage a pool of worker threads, reducing the overhead of thread creation and destruction. The Executors factory class provides utility methods to create various types of pools:

• newFixedThreadPool(int n): Creates a pool with a fixed number of threads. If a thread terminates while in use, a new one replaces it.
• newCachedThreadPool(): Creates a pool that creates new threads as needed but reuses previously constructed threads.
• newSingleThreadExecutor(): Creates an executor that uses a single worker thread.

Using fixed thread pools prevents resource exhaustion in high-load scenarios, allowing the application to degrade gracefully rather than crashing.

Fork/Join Framework

Introduced in JDK 7, the Fork/Join framework is designed for work that can be recursively broken down into smaller subtasks. It utilizes the ForkJoinPool and employs a 'work-stealing' algorithm where idle threads steal tasks from busy threads.

A task typically extends RecursiveAction (for void tasks) or RecursiveTask (for tasks returning a value). The logic follows a pattern:

if (task size is small)
  compute directly
else
  split task into subtasks
  invoke subtasks and combine results

The following example demonstrates a blur filter using RecursiveAction:

public class ImageBlurTask extends RecursiveAction {
    private final int[] sourcePixels;
    private final int startIdx;
    private final int length;
    private final int[] destPixels;
    private final int blurWidth = 15;

    public ImageBlurTask(int[] src, int start, int len, int[] dst) {
        sourcePixels = src;
        startIdx = start;
        length = len;
        destPixels = dst;
    }

    protected void computeDirectly() {
        int sidePixels = (blurWidth - 1) / 2;
        for (int i = startIdx; i < startIdx + length; i++) {
            float r = 0, g = 0, b = 0;
            for (int offset = -sidePixels; offset <= sidePixels; offset++) {
                int currentIndex = Math.min(Math.max(i + offset, 0), sourcePixels.length - 1);
                int pixel = sourcePixels[currentIndex];
                r += ((pixel & 0x00ff0000) >> 16) / (float)blurWidth;
                g += ((pixel & 0x0000ff00) >> 8) / (float)blurWidth;
                b += ((pixel & 0x000000ff) >> 0) / (float)blurWidth;
            }
            int newPixel = (0xff000000) | (((int)r) << 16) | (((int)g) << 8) | (((int)b) << 0);
            destPixels[i] = newPixel;
        }
    }

    @Override
    protected void compute() {
        if (length < 100000) {
            computeDirectly();
            return;
        }
        int split = length / 2;
        invokeAll(new ImageBlurTask(sourcePixels, startIdx, split, destPixels),
                  new ImageBlurTask(sourcePixels, startIdx + split, length - split, destPixels));
    }
}

Concurrent Collections and Atomic Variables

The java.util.concurrent package adds thread-safe collections like ConcurrentHashMap and BlockingQueue. These define happens-before relationships to prevent memory consistency errors.

For atomic operations on single variables, java.util.concurrent.atomic provides classes like AtomicInteger. These are often more efficient than using synchronization locks.

class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getValue() {
        return count.get();
    }
}

Platform Environment

Applications run within a platform environment defined by the OS, JVM, and configuration data. Java provides APIs to inspect and configure this environment.

Configuration Utilities

Configuration data is often managed via java.util.Properties, a key-value map where keys and values are strings. It allows loading properties from streams and saving them back.

Properties defaultProps = new Properties();
try (FileInputStream in = new FileInputStream("defaults.cfg")) {
    defaultProps.load(in);
}

Properties appProps = new Properties(defaultProps);
try (FileInputStream appIn = new FileInputStream("app.cfg")) {
    appProps.load(appIn);
}

System Utilities

The System class provides access to system resources. System.getProperty(String key) retrieves properties like java.version or user.home. System.getenv() returns environment variables.

Command-line arguments passed to the main method are accessible via the String[] args array. Parsing numeric arguments requires conversion:

int port = 8080;
if (args.length > 0) {
    try {
        port = Integer.parseInt(args[0]);
    } catch (NumberFormatException e) {
        System.err.println("Invalid port number.");
    }
}

Regular Expressions

The java.util.regex package provides pattern matching capabilities. The core classes are Pattern (compiled regex) and Matcher (engine to perform matches).

Basic Syntax

A simple test harness allows experimenting with regex:

import java.util.regex.*;
import java.io.Console;

public class RegexTester {
    public static void main(String[] args){
        Console console = System.console();
        if (console == null) return;

        while (true) {
            Pattern pattern = Pattern.compile(console.readLine("%nEnter regex: "));
            Matcher matcher = pattern.matcher(console.readLine("Enter input: "));

            boolean found = false;
            while (matcher.find()) {
                console.format("Match '%s' at indices %d to %d.%n",
                    matcher.group(), matcher.start(), matcher.end());
                found = true;
            }
            if(!found) console.format("No match.%n");
        }
    }
}

Character Classes and Metacharacters

Metacharacters (e.g., ?, *, +, .) have special meanings. Character classes define sets of characters:

• [abc]: Matches a, b, or c.
• [^abc]: Matches any character except a, b, or c (negation).
• [a-zA-Z]: Matches a through z (range).
• \d: A digit ([0-9]).
• \w: A word character ([a-zA-Z_0-9]).

Quantifiers

Quantifiers specify how many times an expression should match:

• Greedy: Matches as much as possible (e.g., X*). The matcher consumes the entire input and backs off to find a match.
• Reluctant: Matches as little as possible (e.g., X*?). It starts at the beginning and adds characters one by one.
• Possessive: Matches as much as possible but never backs off (e.g., X*+).

Example for input "xfooxxxxxxfoo":

• Regex .*foo (greedy) matches the entire string.
• Regex .*?foo (reluctant) matches "xfoo" then "xxxxxxfoo".

Capturing Groups

Parentheses () group characters. Groups are numbered by counting opening parentheses from left to right. The backreference \n matches the text captured by group n.

Enter regex: (\d\d)\1
Enter input: 1212
Match '1212' at indices 0 to 4.

Boundary Matchers

Boundaries restrict where matches occur:

• ^: Beginning of line.
• $: End of line.
• \b: Word boundary.