Java lock over object(s) with some partitioning property

I have a class with some property (partition in the example below)

class Car {
   public String partition;
   ....
}

and I have a function

private void doSomething(Car car){
   //  
     Object obj = getLock(car); // should write this function
     synchronized (obj){
          // do work here
     }

}

If I have 2 instances of the Car object

from 2 different threads the function doSomething is called. the synchronize block should sync only objects with the same "partition" value. When 2 car object have a different partition key they can both enter the block of code at the same time

I was wondering how to write the "getLock" function. Should I use some map

Map<String,Object> ? 

Is there a better way prevent 2 object with same property to enter the critical section?

Yes, using a Map<String, Object> would be a suitable approach to implement the getLock function in order to achieve synchronization based on the partition property of the Car objects. The map can be used to store lock objects for each unique partition value.

an example implementation:

import java.util.HashMap;
import java.util.Map;

class Car {
    public String partition;
    // ...
}

public class CarManager {
    private Map<String, Object> lockMap = new HashMap<>();

    private Object getLock(Car car) {
        String partition = car.partition;
        synchronized (lockMap) {
            // Check if a lock object exists for the partition
            if (!lockMap.containsKey(partition)) {
                // If not, create a new lock object and store it in the map
                lockMap.put(partition, new Object());
            }

            // Return the lock object for the partition
            return lockMap.get(partition);
        }
    }

    private void doSomething(Car car) {
        Object obj = getLock(car);
        synchronized (obj) {
            // do work here
        }
    }
}

If you definitely want to use locking, I would have a look at a striped lock. Some pseudo-code:

class CarManager{
    final Object[] lockStripe = new Object[Runtime.availableProcessors()*4];

     public CarManager(){
        for(int k=0;k<lockStripe.length;k++){
           lockStripe[k]=new Object();
        }
     }

     Object getLock(Car car){
	     int hash = car.partition.hashCode();
	     int lockIndex;
	
	       if (hash == Integer.MIN_VALUE) {
              lockIndex = 0;
           } else {
      	       lockIndex = abs(hash) % lockStripe.length;
           }
      
           return lockStripe[lockIndex];
     }

     public void doSomething(Car car){
	     synchronized(getLock(car)){
            ...
	     }
     }

This approach will ensure that:

1. cars in the same partition will end up with the same lock.
2. cars in different partitions have a low probability of ending up with the same lock. And you can make a trade-off between memory utilization and contention by changing the length of the lockStripe.
3. no global lock is acquired
4. no locks on objects you don't own like locking on the partition object.
5. no memory leaks due to retaining locks of objects that do not exist any longer.
6. no data races