Synchronizing the run() method of a Runnable is completely pointless unless you want to share the Runnable among multiple threads and you want to sequentialize the execution of those threads. Which is basically a contradiction in terms. There is in theory another much more complicated scenario in which you might want to synchronize the run() … Read more
@synchronized does make code thread safe if it is used properly. For example: Lets say I have a class that accesses a non thread safe database. I don’t want to read and write to the database at the same time as this will likely result in a crash. So lets say I have two methods. … Read more
If you really need synchronization of the rest of the constructor versus any threads which anyhow gets a reference to your not-yet-totally-constructed object, you can use a synchronized-block: public class Test { public Test() { final Test me = this; synchronized(this) { new Thread() { @Override public void run() { // … Reference ‘me,’ the … Read more
Before I go into this explanation, you need to understand one optimization that compilers do (my explanation is very simplified). Suppose that somewhere in your code you have such a sequence: int x = a; int y = a; It is perfectly valid for a compiler to re-order these into: // reverse the order int … Read more
A synchronized method uses the method receiver as a lock (i.e. this for non static methods, and the enclosing class for static methods). Synchronized blocks uses the expression as a lock. So the following two methods are equivalent from locking prospective: synchronized void mymethod() { … } void mymethod() { synchronized (this) { … } … Read more
Personally I almost never lock on “this”. I usually lock on a privately held reference which I know that no other code is going to lock on. If you lock on “this” then any other code which knows about your object might choose to lock on it. While it’s unlikely to happen, it certainly could … Read more
As earlier answerers have noted, it is best practice to synchronize on an object of limited scope (in other words, pick the most restrictive scope you can get away with, and use that.) In particular, synchronizing on this is a bad idea, unless you intend to allow the users of your class to gain the … Read more
The get() method is thread-safe, and the other users gave you useful answers regarding this particular issue. However, although ConcurrentHashMap is a thread-safe drop-in replacement for HashMap, it is important to realize that if you are doing multiple operations you may have to change your code significantly. For example, take this code: if (!map.containsKey(key)) return … Read more
Both methods lock the same monitor. Therefore, you can’t simultaneously execute them on the same object from different threads (one of the two methods will block until the other is finished).
I think its best to cite Java Concurrency in Practice here: It is a common mistake to assume that synchronization needs to be used only when writing to shared variables; this is simply not true. For each mutable state variable that may be accessed by more than one thread, all accesses to that variable must … Read more