Thread Synchronization in Java

 Thread Synchronization in Java

Thread synchronization in Java is a mechanism to control the access of multiple threads to shared resources. Without synchronization, it’s possible for one thread to modify a shared variable while another thread is in the middle of using or updating the same variable, leading to inconsistent results.

Why Synchronization?

Consider a scenario where multiple threads are trying to access and modify a shared resource like a bank account balance. Without synchronization, two threads could simultaneously read the balance, add a different amount, and write back the new balance, leading to a lost update.

Achieving Synchronization

Java provides several mechanisms to achieve thread synchronization:

  • Synchronized Method
  • Synchronized Block
  • Reentrant Locks (in java.util.concurrent.locks package)

Synchronized Method

When you declare a method as synchronized, the thread holds the monitor for that method’s object. If another thread is executing the synchronized method, any other thread that tries to call any synchronized method on the same object will be blocked until the first thread is done.

Example:
class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}
class CounterIncrementer extends Thread {
    private final Counter counter;

    public CounterIncrementer(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }
}
public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

        CounterIncrementer t1 = new CounterIncrementer(counter);
        CounterIncrementer t2 = new CounterIncrementer(counter);

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

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

        System.out.println("Count: " + counter.getCount());
    }
}

Explanation

  1. Counter Class:

    • Contains the shared resource count.
    • The increment method is declared as synchronized to ensure that only one thread can execute this method at a time, making it thread-safe.

  2. CounterIncrementer Class:

    • Extends the Thread class and is responsible for incrementing the counter.
    • In the run method, it loops to increment the counter 1000 times.
    • The CounterIncrementer constructor takes a Counter object as a parameter to ensure the shared resource is accessed.

  3. Main Class:

    • Creates a shared Counter object.
    • Creates two CounterIncrementer threads, each initialized with the shared Counter instance.
    • Starts both threads and waits for them to complete using join.
    • Prints the final count.

This implementation uses the Thread class directly, demonstrating thread creation and execution by extending Thread. The synchronized method ensures that the increment method is executed atomically by one thread at a time.

Synchronized Block

A synchronized block is used to synchronize a specific block of code inside a method. It is more efficient than synchronized methods because you can control the scope of synchronization, limiting it to a critical section.

Example:
class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}
class CounterIncrementer extends Thread {
    private final Counter counter;

    public CounterIncrementer(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }
}
public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

        CounterIncrementer t1 = new CounterIncrementer(counter);
        CounterIncrementer t2 = new CounterIncrementer(counter);

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

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

        System.out.println("Count: " + counter.getCount());
    }
}

Explanation

  1. Counter Class:

    • Contains the shared resource count.
    • The increment method uses a synchronized block to ensure thread-safe access to the count variable. The lock object is used as a monitor to synchronize the block.

  2. CounterIncrementer Class:

    • Extends the Thread class and is responsible for incrementing the counter.
    • In the run method, it loops to increment the counter 1000 times.
    • The CounterIncrementer constructor takes a Counter object as a parameter to ensure the shared resource is accessed.

  3. Main Class:

    • Creates a shared Counter object.
    • Creates two CounterIncrementer threads, each initialized with the shared Counter instance.
    • Starts both threads and waits for them to complete using join.
    • Prints the final count.

This implementation uses a synchronized block within the Counter class to control access to the count variable, ensuring that only one thread can increment the counter at a time. The lock object is used to synchronize the block of code that modifies the shared resource.

Reentrant Locks

Reentrant locks provide more flexibility and features compared to synchronized methods/blocks. They are part of the java.util.concurrent.locks package and offer advanced operations like try-lock and timed-lock.

Below is the example implemented using ReentrantLock from the java.util.concurrent.locks package instead of synchronized blocks or methods.

import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}
class CounterIncrementer extends Thread {
    private final Counter counter;

    public CounterIncrementer(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }
}
public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

        CounterIncrementer t1 = new CounterIncrementer(counter);
        CounterIncrementer t2 = new CounterIncrementer(counter);

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

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

        System.out.println("Count: " + counter.getCount());
    }
}

Explanation

  1. Counter Class:

    • Contains the shared resource count.
    • Uses a ReentrantLock object to ensure thread-safe access to the count variable.
    • The increment method locks the lock before updating count and unlocks it in a finally block to ensure that the lock is released even if an exception is thrown.

  2. CounterIncrementer Class:

    • Extends the Thread class and is responsible for incrementing the counter.
    • In the run method, it loops to increment the counter 1000 times.
    • The CounterIncrementer constructor takes a Counter object as a parameter to ensure the shared resource is accessed.

  3. Main Class:

    • Creates a shared Counter object.
    • Creates two CounterIncrementer threads, each initialized with the shared Counter instance.
    • Starts both threads and waits for them to complete using join.
    • Prints the final count.

This implementation uses ReentrantLock to control access to the shared count variable. The lock provides more flexibility and control compared to synchronized methods or blocks, allowing for more complex synchronization scenarios. The lock and unlock methods are used to acquire and release the lock, respectively. The use of a finally block ensures that the lock is always released, even if an exception occurs.

Comments

Post a Comment

Popular posts from this blog

Introduction to Java Swing

Introduction to Java Swing Java Swing is a part of Java Foundation Classes (JFC) and provides a set of APIs for creating graphical user interfaces (GUIs) in Java. It is built on top of the Abstract Window Toolkit (AWT) and offers a richer set of GUI components. Swing is a platform-independent, lightweight toolkit that can be used to create window-based applications. Key Features of Swing Lightweight Components : Swing components are lightweight because they are written entirely in Java and do not rely on native platform components. Pluggable Look and Feel : Swing supports pluggable look and feel, which means you can change the appearance of your application to match different platforms (e.g., Windows, macOS, Linux) or create a custom look and feel. Component-based Architecture : Swing follows a component-based architecture, allowing for reusable, modular, and easily extendable components. MVC Architecture : Swing components follow the Model-View-Controller (MVC) design pattern, separa...
Read more

KTU OOP LAB JAVA CSL 203 BTech CS S3 - Dr Binu V P

About Me Scheme and Evaluation Syllabus and Practice Questions ******************************** How to do Java Programs in  Debian PART A Basic Java Programs Using Control  Statements 1.String Problems 2.Numerical Problems 3.Arrays 4.Matrix Lab Exercise Java-1 PART B  Object Oriented Programming 1.Creating classes and objects. constructor for initializing object 2.Method overloading in Java 3.Single Inheritance 4.Multilevel Inheritance 5.Method overriding in Java 6. Hierarchical Inheritance 7.Interface in Java 8.Abstract classes in java  PART C Exception and File Handling 1.Exception Handling in Java 2.Reading and Writing Text Files 3.Buffered Reader and String Tokenizer PART D Multi-Threading  Creating Threads in Java Thread Synchronization in Java Thread Priorities in Java Programs using Multi-Threading PART E Graphics and Database Programming Introduction to Java Swing Drawing Shapes Drawing  a Sine Wave Handling Mouse Events Handling Keyboard ...
Read more

JDBC Application Program

Write a program to accept rollno, name, CGPA of “n” students and store the data to a database using JDBC connectivity. Display the list of students having CGPA greater than 7. (Use MySQL /PostgreSQL). Steps: Set up MySQL Database : Ensure MySQL is running and create a database and table. Add MySQL Connector/J : Include the JDBC driver for MySQL in your project. Java Program : Write the Java program to interact with the database. 1. Set up MySQL Database Execute the following SQL commands to create a database and table: CREATE DATABASE studentdb; USE studentdb; CREATE TABLE students (     rollno INT PRIMARY KEY,     name VARCHAR(50),     cgpa FLOAT ); 2. Add MySQL Connector/J Dependency If you are using Gradle, add the following to your build.gradle implementation 'mysql:mysql-connector-java:8.0.33' 3.Java Program import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLExcept...
Read more