Static 变量在 class 级别锁定中的行为

Question

I need some clarity on static variables behavior in class level locking.

Scenario: Consider below class called Data.

public class Data {

    private static int i = 1;
    private static int j = 1;


    public void updateI() {
        synchronized (Data.class) {
            ++i;
            System.out.println(fmt() + " > " + Thread.currentThread().getName() + (" UPDATED > "+ i));
        }
    }

    public void getJ() {
        System.out.println(fmt() + " > " + Thread.currentThread().getName() + (" READ > "+ j));
    }
}

Here,

• Thread-A calls updateI() method and acquires the lock.
• At the same time Thread-B is calling getJ() method.
• Will it be block Thread-B as class level lock is already acquired by Thread-A? Or it will allow to access both methods simultaneously?

Thanks....

Answer 1

In short - it won't be locked.

If you want it to be locked you need to protect the getJ function as well:

public void getJ() {
    synchronized (Data.class) {
        System.out.println(fmt() + " > " + Thread.currentThread().getName() + (" READ > "+ j));
    }
}

That has nothing to do with the fact there are static variables. The variables themselves can't be locked. Only access to them. If you allow un-locked access through getJ, there is nothing to stop you.

Answer 2

Interestingly, You can access lock on the class level variables even when class level synchronized method is running by some other Thread

Example where both the main thread and another thread ' thread ' will run at the same time:

import java.util.Arrays;

public class ThreadExample extends Thread {

public ThreadExample() {
}

public ThreadExample(String[] arr) {
    this.arrObj = arr;
}

private String[] arrObj = new String[2];
private final static ThreadExample obj = new ThreadExample(new String[]{"Hello", "World"});

private static synchronized void call() throws InterruptedException {
        obj.arrObj[0] += 'C';
        System.out.println("Inside Thread ... " + Arrays.toString(obj.arrObj));
        Thread.sleep(5000);
        System.out.println("Inside Thread ... Done");
}

@Override
public void run() {
    try {
        call();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

}

public static void main(String[] args) throws InterruptedException {
    ThreadExample thread = new ThreadExample();

    thread.start();
    Thread.sleep(1000);

    synchronized (ThreadExample.obj) {
        obj.arrObj[1] += "K";
        System.out.println("Main Thread ... " + Arrays.toString(obj.arrObj));
        Thread.sleep(5000);
        System.out.println("Main Thread ... Done");
    }
}

}