interview

home / developersection / interviews / synchronization and inter-thread communication in java

Ask Question

Synchronization and Inter-thread Communication in Java

Ravi Vishwakarma 65 24-Apr-2025
java java 
Updated on 24-Apr-2025
Ravi Vishwakarma

Ravi Vishwakarma

Follow

Ravi Vishwakarma is a dedicated Software Developer with a passion for crafting efficient and innovative solutions. With a keen eye for detail and years of experience, he excels in developing robust software systems that meet client needs. His expertise spans across multiple programming languages and technologies, making him a valuable asset in any software development project.

Can you answer this question?
Answer

1 Answers

Ravi Vishwakarma

Ravi Vishwakarma

24-Apr-2025

In a multi-threaded environment, synchronization ensures that multiple threads can safely access shared resources without causing inconsistent data or conflicts. Inter-thread communication allows threads to communicate with each other, often used for coordinating the execution of threads.

1. Synchronization in Java

Synchronization in Java is done using the synchronized keyword, which can be applied to methods or blocks of code.

a. Synchronized Method

When a method is declared as synchronized, only one thread at a time can execute it, ensuring mutual exclusion.

Example:

class Counter {
    private int count = 0;

    // Synchronized method to ensure thread safety
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class SynchronizationExample {
    public static void main(String[] args) {
        Counter counter = new Counter();

        // Create threads
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Output the final count
        System.out.println("Count: " + counter.getCount());
    }
}

b. Synchronized Block

A synchronized block is used to lock only a particular section of code, instead of the whole method. It helps to minimize the scope of synchronization, improving performance.

Example:

class Counter {
    private int count = 0;

    public void increment() {
        synchronized (this) {  // Lock only this block
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

2. Inter-thread Communication

Java provides mechanisms for threads to communicate and coordinate with each other using the wait(), notify(), and notifyAll() methods. These methods are available in the Object class and can be used for synchronization.

a. wait(), notify(), and notifyAll() Methods

  • wait(): Makes the current thread wait until another thread calls notify() or notifyAll() on the same object.
  • notify(): Wakes up a single thread that is waiting on the object's monitor.
  • notifyAll(): Wakes up all threads waiting on the object's monitor.

Example: Producer-Consumer Problem

Here’s a simple example where one thread produces data and another consumes it.

class SharedResource {
    private int data;
    private boolean available = false;

    public synchronized void produce(int value) throws InterruptedException {
        while (available) {
            wait(); // Wait if data is already available
        }
        data = value;
        available = true;
        notify(); // Notify consumer that data is ready
    }

    public synchronized int consume() throws InterruptedException {
        while (!available) {
            wait(); // Wait if no data is available
        }
        available = false;
        notify(); // Notify producer to produce data
        return data;
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();

        // Producer thread
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    sharedResource.produce(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Consumer thread
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    int value = sharedResource.consume();
                    System.out.println("Consumed: " + value);
                    Thread.sleep(1500);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producer.start();
        consumer.start();
    }
}

b. Important Points for Inter-thread Communication

  • Synchronization ensures that only one thread can access a shared resource at a time.
  • wait() and notify() must be called from within a synchronized block (or method), as these methods operate on the monitor of the object.

3. Deadlock and Thread Safety

Deadlock occurs when two or more threads are blocked forever, waiting for each other to release a resource. To avoid deadlock, you can:

  • Use timeouts in wait().
  • Ensure a consistent locking order.

 

Liked By

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy