Thread synchronization in Java  


Java Synchronization Thread

Thread synchronization in Java  

Thread synchronization is an important concept in Java Multithreading. It is important to achieve thread-safety since in multithreading uses shared resources. We can implement thread-safety using synchronized block and method in Java. Synchronization ensures the control of multiple threads accessing the same resource by allowing only a single thread to access the shared resource.

The main use of Thread Synchronization in Java is to avoid thread interference and prevent inconsistency. When we allow multiple threads to work on the same data, there are chances of data corruption and it might lead to concurrency issues. For example, if two threads access the same file, where 1 thread is writing the file and the other closes the file. This situation can corrupt the file. Hence it is important to synchronize threads. We can achieve this using multiple ways using the synchronized keyword which we will see in detail in this tutorial.

How Thread synchronization works in Java  

We can implement synchronization in Java by using the concept of monitors. Whenever a thread tries to access a shared resource, it acquires a monitor. At a time only one thread can own a monitor. During synchronization, when a thread acquires a lock, it enters the monitor state. Hence it prevents other threads from accessing the lock on the shared resource and entering the monitor. This avoids concurrency and corruption issues. Once the thread completes the action using the locked resource, it releases the lock for other threads to use.

See also
Java Scanner

Types of Synchronization  

There are 2 types of synchronization in Java:

Please click Like if you loved this article?

  • Process synchronization
  • Thread synchronization

Thread Synchronization in JavaPin

Multithreading without synchronization  

Before we understand synchronization, let’s understand the issue related to multithreading without synchronization with the below example.

When we do not use synchronization we get an inconsistent output which means it is not in proper order.

class PrintDemo {
  void display(int x) {
    for(int i=1;i<=3;i++) {
      System.out.println(x+i);
      try {
        Thread.sleep(200);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
      
  }
}

class ThreadA extends Thread {
  PrintDemo p;
  
  ThreadA(PrintDemo p){
    this.p = p;
  }
  public void run() {
    p.display(2);
  }
  
}

class ThreadB extends Thread {
  PrintDemo p;
  
  ThreadB(PrintDemo p){
    this.p = p;
  }
  public void run() {
    p.display(4);
  }
}

public class SyncDemo {

  public static void main(String[] args) {
    PrintDemo p = new PrintDemo();
    ThreadA ta = new ThreadA(p);
    ThreadB tb = new ThreadB(p);
    
    ta.start();
    tb.start();

  }

}
3
5
4
6
5
7

Multithreading with Thread synchronization in Java  

Now, let us see the same example by using the synchronized keyword for the display method. We can observe that the output is consistent and is in proper order. Since we have used the synchronized method, it allows only 1 thread to execute at a time. Hence first ThreadA executes completely after which ThreadB executes.

class PrintDemo {
  synchronized void display(int x) {
    for(int i=1;i<=3;i++) {
      System.out.println(x+i);
      try {
        Thread.sleep(200);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
      
  }
}

class ThreadA extends Thread {
  PrintDemo p;
  
  ThreadA(PrintDemo p){
    this.p = p;
  }
  public void run() {
    p.display(2);
  }
  
}

class ThreadB extends Thread {
  PrintDemo p;
  
  ThreadB(PrintDemo p){
    this.p = p;
  }
  public void run() {
    p.display(4);
  }
}

public class SyncDemo {

  public static void main(String[] args) {
    PrintDemo p = new PrintDemo();
    ThreadA ta = new ThreadA(p);
    ThreadB tb = new ThreadB(p);
    
    ta.start();
    tb.start();

  }

}
3
4
5
5
6
7

Synchronized block  

We can synchronize a specific piece of code inside a method by using the synchronized keyword. In this way, we do not need to synchronize the entire method. Below is an example of a synchronized block that implements Thread synchronization in Java. Only the block of code inside the synchronized block is synchronized. In this case, it allows only 1 thread to access this code at a time.

class displayDemo {
  public void display(String text) {
    synchronized(this) {
      System.out.println("Welcome " + text);
      try {
        Thread.sleep(200);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println("Exiting " + text);
    }
  }
}

class displayThread extends Thread {
  private String text;
  displayDemo d;
  
  displayThread(String text, displayDemo d) {
    this.text = text;
    this.d = d;
  }
  
  public void run() {
    d.display(text);
  }
}

public class SyncBlockDemo {

  public static void main(String[] args) {
    displayDemo d = new displayDemo();
    
    displayThread dt1 = new displayThread("Java", d);
    displayThread dt2 = new displayThread("Thread", d);
    
    dt1.start();
    dt2.start();

  }

}
Welcome Java
Exiting Java
Welcome Thread
Exiting Thread

In some situations, a synchronized block might not be useful. Consider a situation where 2 threads want to only read the content inside the block and update. In this case, we can use Semaphore or read/write locks which we will discuss in upcoming tutorials.

See also
Hashtable in Java

Synchronized method  

Another way to achieve thread synchronization in Java is to synchronize the whole method so that at a time only a single thread accesses the method. For this, we use the synchronized keyword before the method. This will avoid concurrency and inconsistency problems. Below is the same example using the synchronized method. In both cases, we will get the same output.

class displayDemo {
  public synchronized void display(String text) {
    System.out.println("Welcome " + text);
    try {
      Thread.sleep(200);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("Exiting " + text);
    
  }
}

class displayThread extends Thread {
  private String text;
  displayDemo d;
  
  displayThread(String text, displayDemo d) {
    this.text = text;
    this.d = d;
  }
  
  public void run() {
    d.display(text);
  }
}

public class SyncBlockDemo {

  public static void main(String[] args) {
    displayDemo d = new displayDemo();
    
    displayThread dt1 = new displayThread("Java", d);
    displayThread dt2 = new displayThread("Thread", d);
    
    dt1.start();
    dt2.start();

  }

}
Welcome Java
Exiting Java
Welcome Thread
Exiting Thread

Static synchronization  

We can use the synchronized keyword for both static and non-static methods. It works the same way as a synchronized non-static method.

Static synchronization synchronizes the class and not the object. This is another way of implementing Thread synchronization in Java.

class displayDemo {
  public static synchronized void display(String text) {
    System.out.println("Welcome " + text);
    try {
      Thread.sleep(200);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("Exiting " + text);
    
  }
}

Inter-thread communication  

Inter-thread communication or cooperation is the other way to implement Thread synchronization in Java, It controls the communication between the synchronized threads. This means it allows another priority thread to enter the critical section by pausing the currently executing thread. For this, inter-thread communication is very important else it can result in critical issues. We can implement this using the wait(), notify(), and notifyAll() methods of the Object class. We will discuss this in detail in a separate tutorial.

See also
FileInputStream in Java

 

Reference

Please click Like if you loved this article?

1