Mastering Thread‑Safe Classes in Java: 6 Proven Design Strategies

1. Introduction

A thread‑safe class is one that can be used by multiple threads simultaneously without causing race conditions or leaving the object in an inconsistent state. If a class is never accessed by more than one thread, thread safety is irrelevant.

2. Thread‑Safe Class Design

2.1 Stateless Classes

When a class holds no state (no fields), it is inherently thread‑safe because there is nothing to modify.

<code>public class MathHelper {
    public int add(int a, int b) {
        return a + b;
    }
    public static int multiply(int a, int b) {
        return a * b;
    }
    public double calculateAverage(int[] numbers) {
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        return numbers.length > 0 ? (double) sum / numbers.length : 0;
    }
}
</code>

2.2 Immutable Classes

Immutability guarantees thread safety because the object's state cannot change after construction.

<code>public final class ImmutablePoint {
    private final int x;
    private final int y;
    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public int getX() { return x; }
    public int getY() { return y; }
    public ImmutablePoint translate(int dx, int dy) {
        return new ImmutablePoint(x + dx, y + dy);
    }
}
</code>

2.3 Encapsulation and Synchronization

For mutable state, proper encapsulation combined with synchronization is essential.

Step 1: Make fields private

<code>// Bad: public field – not thread‑safe
public class UnsafeCounter {
    public int count; // can be modified by any thread
}
</code>

Step 2: Identify non‑atomic operations and synchronize them

<code>public class SafeCounter {
    private int count;
    public synchronized void increment() { count++; }
    public synchronized void decrement() { count--; }
    public synchronized int getCount() { return count; }
}
</code>

The synchronized keyword ensures that only one thread executes the method at a time, preventing race conditions at the cost of lock overhead.

volatile guarantees visibility of changes across threads but does not provide atomicity.

<code>public class StatusChecker {
    private volatile boolean running = true;
    public void stop() { running = false; }
    public void performTask() {
        while (running) {
            // ...
        }
    }
}
</code>

2.4 Using Thread‑Safe Libraries

Java offers concurrent collections and atomic classes that simplify building thread‑safe components.

<code>public class ThreadSafeUserManager {
    private final ConcurrentHashMap<String, User> users = new ConcurrentHashMap<>();
    private final AtomicInteger userCount = new AtomicInteger(0);
    public void addUser(String id, User user) {
        users.put(id, user);
        userCount.incrementAndGet();
    }
    public User getUser(String id) { return users.get(id); }
    public int getTotalUsers() { return userCount.get(); }
}
</code>

2.5 Thread Confinement

Keeping data local to a thread eliminates sharing altogether. Java 21+ provides ScopedValue for this purpose.

<code>public class ScopedValueExample {
    private static final ScopedValue<String> CURRENT_USER = ScopedValue.newInstance();
    public static void main(String[] args) {
        ScopedValue.where(CURRENT_USER, "Alice").run(() -> {
            processRequest();
            auditAction("data_access");
        });
        ScopedValue.where(CURRENT_USER, "Bob").run(() -> {
            System.out.println("Outer scope: " + CURRENT_USER.get());
            ScopedValue.where(CURRENT_USER, "Charlie").run(() -> {
                System.out.println("Inner scope: " + CURRENT_USER.get());
            });
            System.out.println("Back to outer: " + CURRENT_USER.get());
        });
    }
    private static void processRequest() {
        System.out.println("Processing request for: " + CURRENT_USER.get());
    }
    private static void auditAction(String action) {
        System.out.println("User " + CURRENT_USER.get() + " performed action: " + action);
    }
}
</code>

2.6 Defensive Copying

When a class holds mutable objects, create defensive copies on input and output to protect internal state.

<code>public class DefensiveCalendar {
    private final Date startDate;
    public DefensiveCalendar(Date start) {
        this.startDate = new Date(start.getTime());
    }
    public Date getStartDate() {
        return new Date(startDate.getTime());
    }
}
</code>

3. Summary

Stateless classes eliminate shared state.

Immutable classes forbid any modification after construction.

Proper encapsulation and synchronization protect mutable state.

Concurrent collections and atomic variables provide ready‑made thread‑safe building blocks.

Thread confinement keeps data isolated to a single thread.

Defensive copying prevents external code from corrupting internal state.

Choosing the right lock granularity balances safety and performance.