通过更改运行时监视器将两个线程放入同步块

Question

Note: Even though below scenariois are not valid which violates concept of synchronized block , still I tried to know how it works if so

Created two threads , both threads tries to executes same critical section , suprisingly both threads enters into critical section even though by changing monitor.

public class MultiThreadTest {
    final static ConcurrentHashMap<String,Object> objMap = new ConcurrentHashMap<String, Object>();

    public static void main(String[] args) {
         Thread t1 = new Thread(new MyThread(objMap,"1","T1"));
         Thread t2 = new Thread(new MyThread(objMap,"1","T2"));
         t1.start();
         try {
            Thread.sleep(1000);
        } catch (InterruptedException ex) {
        Logger.getLogger(MultiThreadTest.class.getName()).log(Level.SEVERE,          null, ex);
    }
    t2.start();
    }
}

class MyThread implements Runnable{

    private final ConcurrentHashMap<String,Object> objMap;

    private final String id;

    private final String name;

    public MyThread(ConcurrentHashMap<String,Object> objMap, String id, String name){
        this.objMap = objMap;
        this.id =id;
        this.name = name;
    }

    @Override
    public void run() {
        Object monitor = getMonitor(id);
        synchronized(monitor){
            System.out.println("Thread Entered Critica section is:"+id+" and name is:"+name);

                try {
                    Thread.sleep(10000);
                } catch (InterruptedException ex) {
                    Logger.getLogger(MyThread.class.getName()).log(Level.SEVERE, null, ex);
                }

            System.out.println("Thread Exiting Critical section is:"+id+" and name is:"+name);    

            }

    }

    private Object getMonitor(String id){
        if(objMap.contains(id)){
            return objMap.get(id);
        }else{
            objMap.put(id,new Object());
            return objMap.get(id);
        }
    }

}

Below is output:

Thread Entered Critica section is:1 and name is:T1
Thread Entered Critica section is:1 and name is:T2
Thread Exiting Critical section is:1 and name is:T1
Thread Exiting Critical section is:1 and name is:T2

Seems both Threads enters even though monitor is changed.

Any Help is appreciated..

Answer 1

As I mentioned in my comment, your getMonitor method is a big race condition, because you are not synchronizing on the map object so between the time that you check if the key exists and the time that you put a new object in, the other thread can do the same.

However, since you wait one second before starting the second thread, that is not the issue here.

There issue is that you are using the ConcurrentHashMap.contains(Object) method, which checks if the value exists, not if the key exists like you want. You need to change the method to:

private Object getMonitor(String id){
    synchronized (objMap) {
        if (objMap.containsKey(id)) { // <---- containsKey(...), not contains(...)
            return objMap.get(id);
        } else {
            objMap.put(id, new Object());
            return objMap.get(id);
        }
    }
}

Also, you could have avoided your incorrect conclusion that your monitor was locked twice by different thread by actually checking which monitor you locked:

System.out.println(
    "Thread Entered Critica section is:" + id + " and name is:"
    + name + " and monitor is: " + monitor);

Answer 2

Problem is with your getMonitor method. Changing it has following will fix issue.

private Object getMonitor(String id){
    objMap.putIfAbsent(id, new Object());
    return objMap.get(id);
}

The reason is that your original getMonitor method is prone for Race Condition Issues. The common misconception is that using Thread Safe collections like Vector , ConcurrentHashMap inherently makes your code Thread Safe but it won't.

Your getMonitor has a classic Check-Then-Act style of coding (if else) and your objMap is defined as a static variable so all threads will be accessing the same instance.

With the changes I proposed ( objMap.putIfAbsent ) the race condition can be avoided because Check-Then-Act will now be done inside the safety of the Locking mechanism of objMap

The change prints the following

Thread Entered Critica section is:1 and name is:T1
Thread Exiting Critical section is:1 and name is:T1
Thread Entered Critica section is:1 and name is:T2
Thread Exiting Critical section is:1 and name is:T2