There is one more reason that notify can return: spurious wakeup. This is an unlikely but possible thing, because preventing spurious wakeups is very expensive on some hardware/OS combinations. Because of this you always have to call wait() in a loop and re-check the condition that you are waiting for. During this work it’s easy … Read more
The difference is simple: if the locked-on object is in a static field, then all instances of MyClass* will share that lock (i.e. no two objects will be able to lock on that object at the same time). If the field is non-static, then each instance will have its own lock, so only calls of … Read more
It means that this block of code is synchronized meaning no more than one thread will be able to access the code inside that block. Also this means you can synchronize on the current instance (obtain lock on the current instance). This is what I found in Kathy Sierra’s java certification book. Because synchronization does … Read more
No, you are losing the benefits of ConcurrentHashMap by doing that. You may as well be using a HashMap with synchronized or synchronizedMap() to lock the whole table (which is what you do when wrapping operations in synchronized, since the monitor implied is the entire object instance.) The purpose of ConcurrentHashMap is to increase the … Read more
The answer lies in java.lang.Object.wait(long) whose documentation says: […] This method causes the current thread (call it T) to place itself in the wait set for this object and then to relinquish any and all synchronization claims on this object. […]
A trivial solution would be synchronized(player) { synchronized(field) { // code } } However, make sure that you always lock the resources in the same order to avoid deadlocks. Note that in practice, the bottleneck is the field, so a single lock on the field (or on a dedicated, common lock object, as @ripper234 rightly … Read more
If a synchronized method calls another non-synchronized method, is there a lock on the non-synchronized method The answer depends on the context. If you are in a synchronized method for an object, then calls by other threads to other methods of the same object instance that are also synchronized are locked. However calls by other … Read more
Synchronization by itself would be enough in this case if the first check was within synchronized block (but it’s not and one thread might not see changes performed by another if the variable were not volatile). Volatile alone would not be enough because you need to perform more than one operation atomically. But beware! What … Read more
Yes, it is guaranteed that thread 2 will print “done” . Of course, that is if the write to b in Thread 1 actually happens before the read from b in Thread 2, rather than happening at the same time, or earlier! The heart of the reasoning here is the happens-before relationship. Multithreaded program executions … Read more
public synchronized void foo() { // synchronized! // … }; Is essentially the same as: public void foo() { synchronized (this) { // synchronized! // … } }; The latter is more explicit, so I would generally suggest using that form. Or better using a lock that is a private field instead of the “outer” … Read more