Why does it seem to take a long time for this synchronized block to get a lock?

Total Post:28

 849  View(s)
Rate this:
I am new to multi-threading in java, and I have a question some might find trivial.

I have to debug a third party piece of code and I need some basic information, to know where to look for the problem because the code is very large.

When the following code runs:

public void method()
   long startTime = System.currentTimeMillis();
   synchronized (obj)
      log( "time:" + System.currentTimeMillis() - startTime + " ms" );
I get:

11:13:12 - time: 3816 ms...
11:14:14 - time: 0 ms
Why is taking so long (3816 ms) to get the lock for the object? Where should I look? For example, I would imagine a possible answer would be to look for code which acquires the lock for "obj" i.e. block such as:

synchronized (obj) { ... }
Or is it possible that any modification at the object "obj" without "synchronized" can also lock the object?
  1. Post:397

    Re: Why does it seem to take a long time for this synchronized block to get a lock?

    If it takes a thread that long to obtain a lock, it's because someone else is currently holding it.

    You should look for two things:

    Code blocks which synchronize on the same object or on other references to it (known as synchronized statements) :

    synchronized (obj) {
    Synchronized methods  within the object itself.

    Say obj is of type MyObject, then you should look for methods such as these:
    public class MyObject{
        public synchronized void myMethod() {
    Because they are essentially the same as

    public void myMethod() {
        synchronized (this) {
    So if a thread is executing obj.myMethod(), threads that want to enter a synchronized (obj) will have to wait since they lock on the same object. This, by the way, is the reason why I strongly recommend never using the synchronized method syntax, and always locking over a private (or protected) class member.

    If another thread is currently executing code within such a block, the current thread will be locked out until the other thread finishes.