Object level locking vs Class level locking in java

Table of Contents

Why do you need Synchronization?
Object level locking:
Class level locking:

Synchronization is ability to restrict access to shared resource to only one thread. When two or more threads need access to shared resource, there has to be some mechanism such that shared resource will be used by only one thread. The process by which we can achieve it is called Synchronization.

Why do you need Synchronization?

Let’s understand this with the help of example.
Let’s say you want to count number of request you got for a particular URL. If you get two requests at the same time, then count may be inconsistent.

Without Synchronization:


package org.arpit.java2blog;

public class RequestCounter {

 private int count;

 public int incrementCount()
 {
  count++;
  return count;
 }
}

package org.arpit.java2blog;

public class RequestCounter {

private int count;

public int incrementCount()

{

count++;

return count;

}

For example:
Thread T1 sees count as 20 and increment it to 21. At the same time, thread t2 also sees count as 20 and increment it to 21. This shows that count became inconsistent.

With Synchronization:

You can achieve Synchronization using two ways.

synchronized method
synchronized block

You can not use synchronized with instance or class variables.

synchronized method

You can make whole incrementCount() method synchronized so no two thread can access it parallelly.


package org.arpit.java2blog;

public class RequestCounter {

 private int count;

 public synchronized int incrementCount()
 {
  count++;
  return count;
 }
}

package org.arpit.java2blog;

public class RequestCounter {

private int count;

public synchronized int incrementCount()

{

count++;

return count;

}

For example:
Thread T1 sees count as 20 and increment it to 21. At the same time, thread t2 will now see count as 21 and increment it to 22.

synchronized block

You can make use block to synchronize critical section in incrementCount() method so no two thread can access block concurrently.


package org.arpit.java2blog;

public class RequestCounter {

 private int count;

 public int incrementCount() {
  synchronized (this) {
   count++;
   return count;
  }
 }
}

package org.arpit.java2blog;

public class RequestCounter {

private int count;

public int incrementCount() {

synchronized (this) {

count++;

return count;

}

For example:
Thread T1 sees count as 20 and increment it to 21. At the same time, thread t2 will now see count as 21 and increment it to 22.

There are two types of locking in java.

Object level locking
Class level locking

Object level locking:

Object level locking means you want to synchronize non static method or block so that it can be accessed by only one thread at a time for that instance. It is used if you want to protect non static data.

You can achieve Object level locking by following.

Make method synchronized:


public synchronized int incrementCount()
{
}

public synchronized int incrementCount()

{

}

Using synchronized block and lock on this:


public int incrementCount() {
  synchronized (this) {
   count++;
   return count;
  }

public int incrementCount() {

synchronized (this) {

count++;

return count;

}

Using synchronized block and lock on some other object:


private final Object lock=new Object();
public int incrementCount() {
  synchronized (lock) {
   count++;
   return count;
  }

private final Object lock=new Object();

public int incrementCount() {

synchronized (lock) {

count++;

return count;

}

Class level locking:

Class level locking means you want to synchronize static method or block so that it can be accessed by only one thread for whole class. If you have 10 instances of class, only one thread will be able to access only one method or block of any one instance at a time. It is used if you want to protect static data.

This can be achieved by following:

Make static method synchronized:


public static synchronized int incrementCount()
{
}

public static synchronized int incrementCount()

{

}

Using synchronized block and lock on .class:


public int incrementCount() {
  synchronized (RequestCounter.class) {
   count++;
   return count;
  }

public int incrementCount() {

synchronized (RequestCounter.class) {

count++;

return count;

}

Using synchronized block and lock on some other static object:


private final static Object lock=new Object();
public int incrementCount() {
  synchronized (lock) {
   count++;
   return count;
  }

private final static Object lock=new Object();

public int incrementCount() {

synchronized (lock) {

count++;

return count;

}

Can two threads execute static and non static methods concurrently?

Yes, Since two threads will acquire lock on different objects, they can be executed concurrently without any issues.

If one method of class is synchronized and other method of same class is not synchronized? Can they be executed concurrently by two threads?

Yes, because one thread will require lock to get into synchronized block but second thread which will execute non synchronized method that won’t require any lock, so it can be executed concurrently.

Is it safe to call a synchronized method from another synchronized method?

Yes, it is safe to call a synchronized method from another synchronized method because when you call synchronized method, you will get lock on this object and when you call another synchronized method of same class, it is safe to execute as it already has lock on this object.
For example:


public synchronized void method1() {
  method2();
  // some code
 }

 public synchronized void method2() {
  // some code
 }

public synchronized void method1() {

method2();

// some code

}

public synchronized void method2() {

// some code

}

You are actually doing this.


public void method1() {
  synchronized (this) {
   method2();
   // some code
  }

 }

 public void method2() {
  synchronized (this) {
  // some code
  }
 }

public void method1() {

synchronized (this) {

method2();

// some code

}

public void method2() {

synchronized (this) {

// some code

}

Here if any thread calls method2 from method1, it will already have lock on this object hence It is safe to execute.

Was this post helpful?

Let us know if this post was helpful. Feedbacks are monitored on daily basis. Please do provide feedback as that\'s the only way to improve.

Object level locking vs Class level locking in java

Why do you need Synchronization?

Without Synchronization:

With Synchronization:

synchronized method

synchronized block

Object level locking:

Make method synchronized:

Using synchronized block and lock on this:

Using synchronized block and lock on some other object:

Class level locking:

Make static method synchronized:

Using synchronized block and lock on .class:

Using synchronized block and lock on some other static object:

Can two threads execute static and non static methods concurrently?

If one method of class is synchronized and other method of same class is not synchronized? Can they be executed concurrently by two threads?

Is it safe to call a synchronized method from another synchronized method?

Was this post helpful?

Author

Leave a Reply Cancel reply

Categories

Popular Posts

Let’s be Friends

Why do you need Synchronization?

Without Synchronization:

With Synchronization:

synchronized method

synchronized block

Object level locking:

Make method synchronized:

Using synchronized block and lock on this:

Using synchronized block and lock on some other object:

Class level locking:

Make static method synchronized:

Using synchronized block and lock on .class:

Using synchronized block and lock on some other static object:

Can two threads execute static and non static methods concurrently?

If one method of class is synchronized and other method of same class is not synchronized? Can they be executed concurrently by two threads?

Is it safe to call a synchronized method from another synchronized method?

Was this post helpful?

Related posts:

Share this

Author

Leave a Reply Cancel reply

Let’s be Friends