Object Level vs Class Level Lock

 

  1. Example to understand Object and Class level locks in Java

 

A) Object Level lock example

package com.test;

 

public class Foo implements Runnable {

 

    @Override

    public void run() {

        Lock();

    }

    public void Lock() {

        System.out.println(Thread.currentThread().getName());

        synchronized(this) {

            System.out.println("in block " + Thread.currentThread().getName());

            System.out.println("in block " + Thread.currentThread().getName() + " end");

        }

    }

 

    public static void main(String[] args) {

        Foo b1 = new Foo();

        Thread t1 = new Thread(b1);

        Thread t2 = new Thread(b1);             

        Foo b2 = new Foo();

        Thread t3 = new Thread(b2);             

        t1.setName("t1");

        t2.setName("t2");

        t3.setName("t3");             

        t1.start();

        t2.start();

        t3.start();

    }

}

output:

    t1

    t3

    t2

    in block t3

    in block t1

    in block t3 end

    in block t1 end

    in block t2

    in block t2 end

 

Note that t3 will not block when threads t1 and t2 block. Because the lock is placed on this object and thread t3 has different this object than thread t1, t2.

 

B) Class Level lock example

The code in object level lock, only Foo.class is added in synchronized block. All the threads are getting created using object of Foo class will get blocked.

 

 

package com.test;    

public class Foo implements Runnable {        

    @Override

    public void run() {

        Lock();

    }

 

    public void Lock() {

        System.out.println(Thread.currentThread().getName());

        synchronized(Foo.class) {

            System.out.println("in block " + Thread.currentThread().getName());

            System.out.println("in block " + Thread.currentThread().getName() + " end");

        }

    }

 

    public static void main(String[] args) {

        Foo b1 = new Foo();

        Thread t1 = new Thread(b1);

        Thread t2 = new Thread(b1);             

        Foo b2 = new Foo();

        Thread t3 = new Thread(b2);             

        t1.setName("t1");

        t2.setName("t2");

        t3.setName("t3");             

        t1.start();

        t2.start();

        t3.start();

    }

}

output:

t1

t3

in block t1

in block t1 end

t2

in block t3

in block t3 end

in block t2

in block t2 end

Synchronized block is going to be executed for the same thread.

Important things:

  1. Synchronization in java guarantees that no two threads can execute a synchronized method which requires same lock simultaneously or concurrently.

  2. Synchronized keyword can be used only with methods and code blocks. These methods or blocks can be static or non-static both.

  3. Whenever a thread enters into java synchronized method or block it acquires a lock and whenever it leaves java synchronized method or block it releases the lock. Lock is released even if thread leaves synchronized method after completion or due to any Error or Exception.

  4. java synchronized keyword is re-entrant in nature it means if a java synchronized method calls another synchronized method which requires same lock then current thread which is holding lock can enter into that method without acquiring lock.

  5. Java Synchronization will throw NullPointerException if object used in java synchronized block is null. For example, in above code sample if lock is initialized as null, the synchronized (lock) will throw NullPointerException.

  6. Synchronized methods in Java put a performance cost on your application. So use synchronization when it is absolutely required. 

  7. Also, consider using synchronized code blocks for synchronizing only critical section of your code. It’s possible that both static synchronized and non-static synchronized method can run simultaneously or concurrently because they lock on different object.

  8. According to the Java language specification you cannot use java synchronized keyword with constructor it’s illegal and result in compilation error.

  9. Do not synchronize on non-final field on synchronized block in Java. Because reference of non-final field may change any time and then different thread might synchronizing on different objects i.e. no synchronization at all. Best is to use String class, which is already immutable and declared final.

Comments

Post a Comment

Popular posts from this blog

Java 8 : Find the number starts with 1 from a list of integers

  List<Integer> list = List. of ( 12 , 32 , 14 , 15 , 56 ); //Result->12,14,15 List<String> listString = list.stream().map(String::valueOf).collect(Collectors.toList()); List<String> result1 = listString.stream().filter(x->x.startsWith( "1" )) .collect(Collectors.toList()); System. out .println( "result1-->" +result1); List<String> result2 = list.stream().map(x->x+ "" ).filter(x->x.startsWith( "1" )) .collect(Collectors.toList()); System. out .println( "result2-->" +result2);
Read more

Junit Mockito and Power Mockito

Mock vs Spy Both can be used to mock methods or fields. The difference is that  in mock, you are creating a complete mock or fake object while in spy, there is the real object and you just spying or stubbing specific methods of it . Mock vs InjectMock @Mock  creates a mock.  @InjectMocks  creates an instance of the class and injects the mocks that are created with the  @Mock  (or  @Spy ) annotations into this instance. Unit Testing Void Methods with Mockito and JUnit How to Test Void Methods  As we already know that our aim is to test void methods in a class. But it is also really important to understand why we test void methods.  Whenever we write unit test cases for any method, we expect a return value from the method. Generally, we use assert for checking if the method returns the value that we expect it to return, but in the case of void methods, they do not return any value. So how do we check if our method is functioning properly? Let’s...
Read more

Customized Immutable Class

Image
Java Immutable Class In Java, when we create an object of an immutable class, we cannot change its value. For example, String is an immutable class. Hence, we cannot change the content of a string once created. Besides, we can also create our own custom immutable classes. Here's what we need to do to create an immutable class. declare the class as final so it cannot be extended all class members should be private so they cannot be accessed outside of class shouldn't contain any setter methods to change the value of class members the getter method should return the copy of class members class members are only initialized using constructor. PROS - Immutable Object is Threadsafe. For Constant Value. Used as a HashMap Key. (String, Integer, all wrapper classes are immutable) Why Hashmap key should be immutable? Immutability allows you to get same hash code every time, for a key object. So it actually solves most of the problems in one go. Also, this class must honor the hashCode() ...
Read more