The statement is basically talking about when you use the synchronized
word as part of a
method signature. In your example, a synchronized block is used, which has a little more flexibility.
In the example, the run() method must be overridden for
Thread and therefore run() can not be static. However, synchronizing the run method won't solve our problem because it will only lock the single Thread instance - so nothing stops the second Thread instance from running!
So we need to put a lock on something more... unique. Enter the synchronized
block! Using the block, we can put a lock on a static source even when we're in a non-static method. A block would also let us lock something non-static (like
this) from our non-static method, but we already determined we needed something more unique.
So our block can put a lock on a static resource. The next time such a block is reached in code, it sees that the one single static resource is locked and this second block will simply have to wait until the first block is finished.