query: java.concurrent.ReentrantLock - why we want to acquire the same lock multiple times
positive_passages.docid: 148371
positive_passages.text: Why use a ReentrantLock if one can use synchronized(this)?
negative_passages.docid: 19589
negative_passages.text: Recursive Lock (Mutex) vs Non-Recursive Lock (Mutex)
negative_passages.docid: 100941
negative_passages.text: Synchronising twice on the same object?
negative_passages.docid: 8843
negative_passages.text: Is there an advantage to use a Synchronized Method instead of a Synchronized Block?
negative_passages.docid: 57935
negative_passages.text: Why does the instance need to be recreated when restarting a thread?
negative_passages.docid: 48729
negative_passages.text: Creating manual threads, also tried using parallel.foreach and async await - but getting duplicate
negative_passages.docid: 117920
negative_passages.text: ConcurrentModificationException Woes
negative_passages.docid: 156341
negative_passages.text: How this java code produces deadlock?
negative_passages.docid: 86430
negative_passages.text: Can anyone explain me over ConcurrentModificationException?
negative_passages.docid: 124287
negative_passages.text: Connection Pool returns Same Exception Instance to Two Threads Using the Same Bad Connection String?
negative_passages.docid: 60648
negative_passages.text: Is Meyers' implementation of the Singleton pattern thread safe?
negative_passages.docid: 142239
negative_passages.text: Java "ConcurrentModificationException" runtime error when iterating .next()
negative_passages.docid: 42599
negative_passages.text: Java Synchronization
negative_passages.docid: 124651
negative_passages.text: Using sp_getapplock to implement a queue. Is it correct? Is there a better way?
negative_passages.docid: 24320
negative_passages.text: How do you implement a re-try-catch?
negative_passages.docid: 82479
negative_passages.text: Java volatile reference vs. AtomicReference
negative_passages.docid: 157142
negative_passages.text: Deadlock caused by thread.join() in a static block