«Back to Home

Core Java
Topics

Static Synchronization In Java

Static Synchronization
 
In Java, if we create any static method as synchronized, the lock will be on the class and not on the object.
 
Without static synchronization

Assume that, there are two objects of a shared class named a1 and a2. In case of synchronized method and synchronized block, here cannot be interference between t1 and t2 or t3 and t4 because t1 and t2 both refers to a common object, which have a single lock. There can be an interference between t1 and t3 or t2 and t4 because t1 gets another lock and t3 gets another lock and if we want no interference between t1 and t3 or t2 and t4 that time, we need to use static synchronization. Static synchronization solves these types of problems in Java.

14
 
Let’s see an example: with static synchronization, given below.
 
Code
  1. class C {  
  2.     synchronized static void print(int n) {  
  3.         for (int i = 1; i <= 4; i++) {  
  4.             System.out.println(n * i);  
  5.             try {  
  6.                 Thread.sleep(1500);  
  7.             } catch (Exception e) {}  
  8.         }  
  9.     }  
  10. }  
  11. class Thread1 extends Thread {  
  12.     public void run() {  
  13.         C.print(10);  
  14.     }  
  15. }  
  16. class Thread2 extends Thread {  
  17.     public void run() {  
  18.         C.print(100);  
  19.     }  
  20. }  
  21. class Thread3 extends Thread {  
  22.     public void run() {  
  23.         C.print(1000);  
  24.     }  
  25. }  
  26. public class StaticSynchronization {  
  27.     public static void main(String t[]) {  
  28.         Thread1 t1 = new Thread1();  
  29.         Thread2 t2 = new Thread2();  
  30.         Thread3 t3 = new Thread3();  
  31.         t1.start();  
  32.         t2.start();  
  33.         t3.start();  
  34.     }  
  35. }  
15
16

Output

17

In the example, shown above, we apply synchronized keyword on the static method to execute static synchronization.
 
Let’s see an example with annonynmous class.
 
Code
  1. class C {  
  2.     synchronized static void print(int n) {  
  3.         for (int i = 1; i <= 4; i++) {  
  4.             System.out.println(n * i);  
  5.             try {  
  6.                 Thread.sleep(1500);  
  7.             } catch (Exception e) {}  
  8.         }  
  9.     }  
  10. }  
  11.   
  12. public class StaticSynchronization {  
  13.     public static void main(String[] args) {  
  14.         Thread t1 = new Thread() {  
  15.             public void run() {  
  16.                 C.print(10);  
  17.             }  
  18.         };  
  19.         Thread t2 = new Thread() {  
  20.             public void run() {  
  21.                 C.print(100);  
  22.             }  
  23.         };  
  24.         Thread t3 = new Thread() {  
  25.             public void run() {  
  26.                 C.print(1000);  
  27.             }  
  28.         };  
  29.         t1.start();  
  30.         t2.start();  
  31.         t3.start();  
  32.     }  
  33. }  
18
19

Output

20

In the example, shown above, we use anonymous class to create threads.
 
Synchronized block on a class lock

The synchronized block synchronizes on the lock of the object indicated by the reference .class name .class and a static synchronized method print(int n) in class C is equal to the declaration, given below.
 
static void print(int n) {
    synchronized (C.class) {
       // ... code
    }
}
 
Summary

Thus, we learnt that in Java, if we create any static method as synchronized, the lock will be on the class not on the object and also learnt how we can create it in Java.