I am looking for a type of lock where the thread that holds the lock can pass it on to another thread of its choosing.
Here is why I want it:
- I have a class similar to
ConcurrentHashMap– a specialized collection that is divided into multiple segments - Most modifications require only one segment to be locked. A few require two segments to be locked (specifically, modifying a key so that it moves from one segment to another.)
- Most reads do not require locking – a volatile read is usually sufficient, but occasionally a search needs to lock all segments at once, if a modification-count check fails
- Searching is done in multiple threads (via a
ThreadPoolExecutor) - It is essential that the search function has a consistent view of all segments (e.g. it must not miss an entry while it is being moved from one segment to another.)
- The search task (for a single segment) may be interrupted at any time.
Now I am considering the situation where the search method has been called in the main thread and discovers it needs to lock all segments. All of the segment locks must be held at once by the main thread (to ensure there is no interference) but it is not the main thread that will be doing the updates – it is one of the worker threads. Hence I am trying to make the main thread “pass on” the locks once it knows it has a consistent snapshot.
We used to use a single lock for the whole collection but as it got larger there was too much contention and unacceptably high latency for small updates.
Unlocking and re-locking (on a ReentrantLock) is not safe – another thread may modify the segment before the worker thread starts the search.
A plain Semaphore can handle locking and unlocking by different threads. The issue that then arises is who should release the semaphore – the worker thread needs a way to signal that it has taken ownership of the lock (because it may throw an exception before or after this point and the main thread needs to know whether to clean up.) It would also be tricky to unit-test because you never know if a semaphore acquire or release has occurred in the correct thread.
It would be a bonus if the lock could be used reentrantly in other methods (where it is not passed between threads.)
I imagine some combination of a Semaphore and an AtomicBoolean or AtomicReference is called for, but a quick google search did not reveal any examples. Is there any reason why this approach should not be used?
An inverted use of a read/write lock may work. In this idiom, the read lock holders perform concurrent writes to the data structure (e.g. independent slots in an array). The write lock is used to acquire exclusive access to perform a consistent read (e.g. summing the array). This is a rarely used idiom, but elegant in those oddball cases. Your problem is a bit hard to grok, but this may at least offer some inspiration for a concrete solution. I suspect with a deeper understanding, the problem could be simplified so that a classical solution is more appropriate.