Java: how to dynamically synchronize a method

Question

I have the following use case: I have a class that has two methods m1 and m2. Normally, m1() need not be synchronized, however if someone calls m2(), then m1() needs to be synchronized as long as m2() is being executed. In order to achieve this, I came up with the following code. Could you pl. comment on it and suggest better options?

Note: I realize that this situation is not practical, because e.g. if some thread is in the middle of m1 and some other thread calls m2, then there would be a problem (and it would be great if someone points out how to take care of that); nonetheless I found thinking about this interesting.

public class DynamicSync
{
    volatile MyLock lock;   
    private final MyLock DUMMY_LOCK = new DummyMyLock();
    private final MyLock SYNCHRONIZED_LOCK = new SynchronizedMyLock();

    public DynamicSync()
    {
        lock = DUMMY_LOCK;
    }

    public void dynamicallySynchronizedMethod() // this is method m1() in the question above
    {
        lock.lock();
        // some logic
        lock.unlock();
    }

    public void setLockAndExecuteLogic() // this is method m2() in the question above
    {       
        synchronized(SYNCHRONIZED_LOCK)
        {
            lock = SYNCHRONIZED_LOCK;       
            // some logic                               
        }
    }

    interface MyLock
    {
        void lock();
        void unlock();
    }

    class DummyMyLock implements MyLock
    {
        @Override
        public void lock() 
        {
        }

        @Override
        public void unlock() 
        {
        }       
    }

    class SynchronizedMyLock implements MyLock
    {
        @Override
        public synchronized void lock() 
        {
            // no op
        }

        @Override
        public void unlock() 
        {
            lock = DUMMY_LOCK;
        }       
    }
}

EDIT: the actual problem is: I'm designing an object pool, where I need to know how many and which of the objects are given out, and how many remain. So I was thinking of maintaining two collections: origSet would be a HashSet that contains all the objects and dynaSet would be a ConcurrentSkipListSet from which I give out objects and put them back in. If I need to figure out the difference between origSet and dynaSet at an instant, I need to 'freeze' dyanSet till the difference is calculated. But getting this difference will be a very infrequent operation, hence my question.

Answer 1

Be safe, make them both synchronized. Unless you are capable of coming up with a concurrent correctness proof for whatever you come up with, or whatever may be suggested here, the risk is not worth it.

EDIT: I recant. It finally dawned on me that this is rather like a shared-read lock, even before reading the other answer that says so ;-) Make m1() claim a shared-read lock and makem2() claim a write lock. Then any number of m1()s can run simultaneously but m1() & m2() can't run at the same time, and no two m2()s can run at the same time.

Answer 2

Java has an extensive API for multi-threading Synchronization so I warmly suggest you don't try writing anything like that if you do not want to die suffering in the hell of race conditions.

If you have already read the book http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz , then you should now:

• The best solution would be to stay immutable and kick thread-synchronization problems out of your world.
• If you can't stay immutable, stay defensive and make defensive copies of your internal properties when sharing them. This is called "safe publication"
• If you can't stay immutable, try at least to use concurrent collections to make your life easier.
• If you really need to develop your own locking system, please have a look to Java ReadWriteLock.

According to your last comments, I have two proposals:

1. If you just need to get the size of the collection, but not doing anything on the collection using the data. I do not think you need to synchronize at all. Your call to getDynaSize will return the last available value: not sure it is the current one when you will use it, but unless you clearly see race conditions inside your processing method, do not synchronize at all. (maybe you want to give us more details?)

2. If you really need to lock, use a ReadWriteLock,

   • It is a reentrant lock, so that if a Thread has already acquired, a consequent try to acquire will be non blockin, it allows for multiple readers to enter, but only one writer.
   • You need to acquire the writer every time you need to add an element to your concurrent collection, and release it after adding it. And also, you have to acquire the writer lock before getting the size, and release it after having completed the processing

Answer 3

I would suggest using a ReadWriteLock for this. Protect m1() with the readLock() and m2() with the writeLock().