Thread Synchronization, Critical Sections, and synchronized Methods/Blocks0%

Inter-Thread Communication: wait(), notify(), and notifyAll()

Thread Synchronization, Critical Sections, and synchronized Methods/Blocks

Advanced16 min read•Updated: 2025-01-15

🔒 Thread Synchronization, Critical Sections, and synchronized Methods/Blocks

Introduction

When multiple concurrent threads read and write to the same shared mutable memory without coordination, a race condition occurs, resulting in non-deterministic data corruption.

To guarantee thread safety, Java provides the synchronized keyword to enforce mutual exclusion on critical sections.

💥 The Race Condition Danger

1public class UnsafeCounter {
  private int count = 0;
3 
  // NOT THREAD SAFE!
  public void increment() {
      // count++ is NOT atomic! It is 3 bytecode operations:
      // 1. Read count from memory
      // 2. Add 1 to count
      // 3. Write new count back to memory
      count++; 
  }
12}

If two threads execute this simultaneously, one update overwrites the other, causing silent data loss!

🛡️ 1. Synchronized Methods

Adding synchronized to an instance method causes the executing thread to acquire the object's intrinsic lock (monitor):

1public class SafeCounter {
2    private int count = 0;
3 
4    public synchronized void increment() {
5        count++; // Atomically protected by this object's lock
6    }
7 
8    public synchronized int getCount() {
9        return count;
10    }
11}

🎯 2. Synchronized Blocks (Finer Granularity)

Synchronizing an entire method can cause thread contention and throttle throughput. Synchronized blocks protect only the minimal critical section:

1public class AccountService {
  private final Object balanceLock = new Object();
  private double balance = 10000.0;
4 
  public void transfer(double amount) {
      // Unsynchronized preparatory work (e.g. validation, audit logging)
      validateAmount(amount);
8 
      // Minimal synchronized block:
      synchronized (balanceLock) {
          balance -= amount;
      }
13 
      // Unsynchronized post-work
      sendNotification();
  }
17}

💡 The `volatile` Keyword

The volatile modifier ensures that a variable is always read directly from and written to main memory, preventing CPU cache incoherence across cores:

1public class ServerStatus {
2    // Guaranteed visible across all CPU caches immediately
3    private volatile boolean isRunning = true;
4 
5    public void stopServer() {
6        isRunning = false;
7    }
8}

Next Lesson

Inter-Thread Communication: wait(), notify(), and notifyAll()

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Thread Lifecycle, Creating Threads with Thread Class and Runnable Interface	Inter-Thread Communication: wait(), notify(), and notifyAll()

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Inter-Thread Communication: wait(), notify(), and notifyAll()

Thread Synchronization, Critical Sections, and synchronized Methods/Blocks

Advanced16 min read•Updated: 2025-01-15

Study Materials

🔒 Thread Synchronization, Critical Sections, and synchronized Methods/Blocks

Introduction

When multiple concurrent threads read and write to the same shared mutable memory without coordination, a race condition occurs, resulting in non-deterministic data corruption.

To guarantee thread safety, Java provides the synchronized keyword to enforce mutual exclusion on critical sections.

💥 The Race Condition Danger

1public class UnsafeCounter {
  private int count = 0;
3 
  // NOT THREAD SAFE!
  public void increment() {
      // count++ is NOT atomic! It is 3 bytecode operations:
      // 1. Read count from memory
      // 2. Add 1 to count
      // 3. Write new count back to memory
      count++; 
  }
12}

If two threads execute this simultaneously, one update overwrites the other, causing silent data loss!

🛡️ 1. Synchronized Methods

Adding synchronized to an instance method causes the executing thread to acquire the object's intrinsic lock (monitor):

1public class SafeCounter {
2    private int count = 0;
3 
4    public synchronized void increment() {
5        count++; // Atomically protected by this object's lock
6    }
7 
8    public synchronized int getCount() {
9        return count;
10    }
11}

🎯 2. Synchronized Blocks (Finer Granularity)

Synchronizing an entire method can cause thread contention and throttle throughput. Synchronized blocks protect only the minimal critical section:

1public class AccountService {
  private final Object balanceLock = new Object();
  private double balance = 10000.0;
4 
  public void transfer(double amount) {
      // Unsynchronized preparatory work (e.g. validation, audit logging)
      validateAmount(amount);
8 
      // Minimal synchronized block:
      synchronized (balanceLock) {
          balance -= amount;
      }
13 
      // Unsynchronized post-work
      sendNotification();
  }
17}

💡 The `volatile` Keyword

The volatile modifier ensures that a variable is always read directly from and written to main memory, preventing CPU cache incoherence across cores:

1public class ServerStatus {
2    // Guaranteed visible across all CPU caches immediately
3    private volatile boolean isRunning = true;
4 
5    public void stopServer() {
6        isRunning = false;
7    }
8}

Next Lesson

Inter-Thread Communication: wait(), notify(), and notifyAll()

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Thread Lifecycle, Creating Threads with Thread Class and Runnable Interface	Inter-Thread Communication: wait(), notify(), and notifyAll()

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

🔒 Thread Synchronization, Critical Sections, and synchronized Methods/Blocks

Introduction

💥 The Race Condition Danger

🛡️ 1. Synchronized Methods

🎯 2. Synchronized Blocks (Finer Granularity)

💡 The volatile Keyword

Inter-Thread Communication: wait(), notify(), and notifyAll()

Related Lessons

Practice Quiz

Loading Page Content...

🔒 Thread Synchronization, Critical Sections, and synchronized Methods/Blocks

Introduction

💥 The Race Condition Danger

🛡️ 1. Synchronized Methods

🎯 2. Synchronized Blocks (Finer Granularity)

💡 The volatile Keyword

Inter-Thread Communication: wait(), notify(), and notifyAll()

Related Lessons

Practice Quiz

💡 The `volatile` Keyword

💡 The `volatile` Keyword