Using an Object by only one thread at a time

I have a collection ( Map<String, MyObject> ). In a multi-threaded environment, I need the instance of myObject in map to be used by only one thread at once. Consider the below example.

public class MyObject{
String name;
public MyObject(String objName){
this.name = name;
}
public void doSomeTimeConsumingAction(){
Thread.sleep(10000);
}
public void doSomeOther(){
//doSomething
}
public void doMany(){
//doSomething
}
}
public class ObjectUtil {
public static Map<String, MyObject> map = new HashMap<>();
static {
map.put("a", new MyObject("a"));
map.put("b", new MyObject("b"));
map.put("c", new MyObject("c"));
}
public static getObject(String key){
return map.get(key);
}
}
public static void main(String[] args){
Thread t1 = new Thread(new Runnable(){
@Override
public void run(){
System.out.println("t1 starts");
MyObject obj = ObjectUtil.getObject("a");
obj.doSomeTimeConsumingAction();
System.out.println("t1 ends");
});
Thread t2 = new Thread(new Runnable(){
@Override
public void run(){
System.out.println("t2 starts");
MyObject obj = ObjectUtil.getObject("a");
obj.doSomeTimeConsumingAction();
System.out.println("t2 ends");
});
Thread t3 = new Thread(new Runnable(){
@Override
public void run(){
System.out.println("t3 starts");
MyObject obj = ObjectUtil.getObject("b");
obj.doSomeTimeConsumingAction();
System.out.println("t3 ends");
});
t1.start();
t2.start();
t3.start();
}

My expected Output

t1 starts
t2 starts
t3 starts
/* wait 10 sec */
t1 ends
t3 ends
/* wait 10 sec */
t2 ends

Explanation --> In the above, threads t1 and t2 both try to access the same instance from the map with the key "a", while t3 accesses different instance with key "b".So, t1, t2, t3 starts concurrently . while t1, t3 (or t2, t3) ends first, then the other one ends.

I cannot use synchronized on map or getObject() method, coz that would not lock the object instance to be used.

Simply put, How can I know if an instance of an object is used by a thread? and, How to prevent other thread from accessing the same instance? Is it possible?

Edit: Updated the code , I cannot synchronize the method doSomeTimeConsumingAction in the object as well, coz then the other methods could br accessed by the thread.It is not about the methods to access, the whole instance should be accessed only by one thread at a time. Forgive me if it is too much to ask.

You want to achieve mutual exclusion with doSomeTimeConsumingAction, so that only one thread at a time can be running the doSomeTimeConsumingAction method of an object at a time.

That's easily achieved by making doSomeTimeConsumingAction synchronized:

public class MyObject{
String name;
public MyObject(String objName){
this.name = name;
}
public synchronized void doSomeTimeConsumingAction(){
Thread.sleep(10000);
}
}

Alternatively, use a synchronized block in the threads themselves, which acquires a lock on the object. This will guarantee mutual exclusion among threads that try to acquire the same lock.

  public void run(){
System.out.println("t2 starts");
MyObject obj = ObjectUtil.getObject("a");
synchronized (obj) {
obj.doSomeTimeConsumingAction();
// call other methods of obj if you want
}
System.out.println("t2 ends");
});

Synchronizing all methods is not OK unless you know each caller would only ever invoke a single method. Otherwise calls can interleave which is usually a bad idea. If in doubt callers should synchronize the whole instance before working on it.

If you don't trust (all) your callers to follow that rule - here's a simple way of "locking" a MyObject.

    public static Map<String, MyObject> map = new ConcurrentHashMap<>();

    public static void handle(String key, Consumer<MyObject> handle) {
      map.computeIfPresent(key, o -> {
        handler.apply(o); // Only one thread can be here at a time for any given "o"
        return o;
      });
    }
    ...
    ObjectUtil.handle("a", o -> o.doSomeTimeConsumingAction());

Whilst short and safe, it is not the greatest threading performance (CHM may also block access to other MyObjects).

This is a textbook example of using synchronized blocks. If you want to have mutual exclusion for an object, you can comfortably declare the doSomeTimeConsumingAction() method as synchronized.

public synchronized void doSomeTimeConsumingAction() throws InterruptedException {
Thread.sleep(10000);
}

Even though you mark the method to be synchronized the actual lock is applied on the object and not on the method. Locks can only be applied to real-time entities like objects, and methods are just logic blocks.

Java is designed in such a way that it puts you in control to make the methods thread-safe, rather than locking the whole object at the class level. So, it's up to you to decide which methods should be synchronized and which shouldn't be.

I understand your dilemma in using synchronized blocks and I recommend you to read more on that and play with it to get more comfortable.