Synchronization & Thread Safety

When multiple threads access shared data simultaneously, race conditions can corrupt data. Synchronization ensures only one thread can access critical sections at a time, maintaining data integrity. This is a foundational concept in enterprise application development that professional developers rely on daily. The explanations below are written to be beginner-friendly while covering the depth and nuance that comes from real-world Java experience. Take your time with each section and practice the examples

45 min•By Priygop Team•Last updated: Feb 2026

Synchronization Example

Example

class BankAccount {
    private double balance;
    private String owner;
    
    BankAccount(String owner, double balance) {
        this.owner = owner;
        this.balance = balance;
    }
    
    // synchronized — only one thread at a time
    synchronized void deposit(double amount) {
        double current = balance;
        try { Thread.sleep(10); } catch (InterruptedException e) {}
        balance = current + amount;
        System.out.println("Deposited $" + amount + " | Balance: $" + balance);
    }
    
    synchronized void withdraw(double amount) {
        if (balance >= amount) {
            double current = balance;
            try { Thread.sleep(10); } catch (InterruptedException e) {}
            balance = current - amount;
            System.out.println("Withdrew $" + amount + " | Balance: $" + balance);
        } else {
            System.out.println("Insufficient funds for $" + amount);
        }
    }
    
    double getBalance() { return balance; }
}

public class SyncDemo {
    public static void main(String[] args) throws InterruptedException {
        BankAccount account = new BankAccount("Alice", 1000);
        
        // Multiple threads accessing the same account
        Thread depositor = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                account.deposit(100);
            }
        });
        
        Thread withdrawer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                account.withdraw(50);
            }
        });
        
        depositor.start();
        withdrawer.start();
        
        depositor.join();
        withdrawer.join();
        
        System.out.println("\nFinal balance: $" + account.getBalance());
        System.out.println("Expected: $1250 (1000 + 500 - 250)");
    }
}

Try It Yourself: Thread-Safe Counter

Try It Yourself: Thread-Safe CounterJava

Java Editor

✓ ValidTab = 2 spaces

import java.util.concurrent.atomic.AtomicInteger;

public class SafeCounter {
    // AtomicInteger is thread-safe without synchronized
    private static AtomicInteger safeCount = new AtomicInteger(0);
    private static int unsafeCount = 0;
    
    public static void main(String[] args) throws InterruptedException {
        int numThreads = 10;
        int incrementsPer = 1000;
        
        Thread[] threads = new Thread[numThreads];
        
        // Create threads that increment both counters
        for (int i = 0; i < numThreads; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < incrementsPer; j++) {
                    safeCount.incrementAndGet();  // Atomic
                    unsafeCount++;                 // NOT thread-safe!
                }
            });
        }
        
        // Start all threads
        for (Thread t : threads) t.start();
        
        // Wait for all to finish
        for (Thread t : threads) t.join();
        
        int expected = numThreads * incrementsPer;
        System.out.println("Expected count: " + expected);
        System.out.println("Atomic (safe): " + safeCount.get());
        System.out.println("Regular (unsafe): " + unsafeCount);
        System.out.println("\nNotice: The unsafe counter may be less than " + expected);
        System.out.println("due to race conditions where increments get lost!");
    }
}

import java.util.concurrent.atomic.AtomicInteger;

public class SafeCounter {
    // AtomicInteger is thread-safe without synchronized
    private static AtomicInteger safeCount = new AtomicInteger(0);
    private static int unsafeCount = 0;
    
    public static void main(String[] args) throws InterruptedException {
        int numThreads = 10;
        int incrementsPer = 1000;
        
        Thread[] threads = new Thread[numThreads];
        
        // Create threads that increment both counters
        for (int i = 0; i < numThreads; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < incrementsPer; j++) {
                    safeCount.incrementAndGet();  // Atomic
                    unsafeCount++;                 // NOT thread-safe!
                }
            });
        }
        
        // Start all threads
        for (Thread t : threads) t.start();
        
        // Wait for all to finish
        for (Thread t : threads) t.join();
        
        int expected = numThreads * incrementsPer;
        System.out.println("Expected count: " + expected);
        System.out.println("Atomic (safe): " + safeCount.get());
        System.out.println("Regular (unsafe): " + unsafeCount);
        System.out.println("\nNotice: The unsafe counter may be less than " + expected);
        System.out.println("due to race conditions where increments get lost!");
    }
}

Output

Click ▶ Run to see the result

Edit the code on the left, then click Run

Java|37 lines|1424 chars|✓ Valid syntax

UTF-8

Quick Quiz: Synchronization

Synchronization & Thread Safety

45 min•By Priygop Team•Last updated: Feb 2026

Synchronization Example

Example

class BankAccount {
    private double balance;
    private String owner;
    
    BankAccount(String owner, double balance) {
        this.owner = owner;
        this.balance = balance;
    }
    
    // synchronized — only one thread at a time
    synchronized void deposit(double amount) {
        double current = balance;
        try { Thread.sleep(10); } catch (InterruptedException e) {}
        balance = current + amount;
        System.out.println("Deposited $" + amount + " | Balance: $" + balance);
    }
    
    synchronized void withdraw(double amount) {
        if (balance >= amount) {
            double current = balance;
            try { Thread.sleep(10); } catch (InterruptedException e) {}
            balance = current - amount;
            System.out.println("Withdrew $" + amount + " | Balance: $" + balance);
        } else {
            System.out.println("Insufficient funds for $" + amount);
        }
    }
    
    double getBalance() { return balance; }
}

public class SyncDemo {
    public static void main(String[] args) throws InterruptedException {
        BankAccount account = new BankAccount("Alice", 1000);
        
        // Multiple threads accessing the same account
        Thread depositor = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                account.deposit(100);
            }
        });
        
        Thread withdrawer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                account.withdraw(50);
            }
        });
        
        depositor.start();
        withdrawer.start();
        
        depositor.join();
        withdrawer.join();
        
        System.out.println("\nFinal balance: $" + account.getBalance());
        System.out.println("Expected: $1250 (1000 + 500 - 250)");
    }
}

Try It Yourself: Thread-Safe Counter

Try It Yourself: Thread-Safe CounterJava

Java Editor

✓ ValidTab = 2 spaces

import java.util.concurrent.atomic.AtomicInteger;

public class SafeCounter {
    // AtomicInteger is thread-safe without synchronized
    private static AtomicInteger safeCount = new AtomicInteger(0);
    private static int unsafeCount = 0;
    
    public static void main(String[] args) throws InterruptedException {
        int numThreads = 10;
        int incrementsPer = 1000;
        
        Thread[] threads = new Thread[numThreads];
        
        // Create threads that increment both counters
        for (int i = 0; i < numThreads; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < incrementsPer; j++) {
                    safeCount.incrementAndGet();  // Atomic
                    unsafeCount++;                 // NOT thread-safe!
                }
            });
        }
        
        // Start all threads
        for (Thread t : threads) t.start();
        
        // Wait for all to finish
        for (Thread t : threads) t.join();
        
        int expected = numThreads * incrementsPer;
        System.out.println("Expected count: " + expected);
        System.out.println("Atomic (safe): " + safeCount.get());
        System.out.println("Regular (unsafe): " + unsafeCount);
        System.out.println("\nNotice: The unsafe counter may be less than " + expected);
        System.out.println("due to race conditions where increments get lost!");
    }
}

import java.util.concurrent.atomic.AtomicInteger;

Output

Click ▶ Run to see the result

Edit the code on the left, then click Run

Java|37 lines|1424 chars|✓ Valid syntax

UTF-8

Synchronization & Thread Safety

Synchronization Example

Try It Yourself: Thread-Safe Counter

Quick Quiz: Synchronization

Topics in This Module

Synchronization & Thread Safety

Synchronization Example

Try It Yourself: Thread-Safe Counter

Quick Quiz: Synchronization

Topics in This Module