線程間不同synchronized方法的調用

    以前在學習java sychronized方法在縣城之間的同步時，一直把注意力集中在同一個synchronized方法的同步，也就是說，以前自己只知道當一個對象獲得了同步鎖，並進入一個synchronized方法（比如a()）中時，另一個線程在同一個對象上不能再進入到a()方法中。今天在看wait方法時突然想到，另一個線程在同一個對象上是否可以調用這個對象上的其他synchronized方法呢？下面的代碼回答了我的問題：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * 測試當一個線程擷取同步鎖進入同步控制方法後，另一個線程是否可以調用同一個
 * 對象的另外一個同步控制方法
 * 
 * 結果證明，在一個線程獲得某對象的鎖，並進入該對象的一個同步方法後，其他線程
 * 是無法再調用該對象的任何同步訪法的，直到那個線程釋放鎖
 *
*/

class TestSynchronized {
public synchronized void f() {
try {
            System.out.println("In function f()");
            System.out.println("In function f(), sleeping");
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e) {
            System.out.println("Exiting via f() exception");
        }
    }

public synchronized void g() {       
        System.out.println("In function g()");
        System.out.println("In function g(), sleeping");           
    }

public void k() {
        System.out.println("In function k");
    }
}

class Run1 implements Runnable {
private TestSynchronized test;
public Run1(TestSynchronized test) {
this.test = test;
    }

    @Override
public void run() {
        test.k();
        test.f();
    }
}

class Run2 implements Runnable {
private TestSynchronized test;
public Run2(TestSynchronized test) {
this.test = test;
    }

    @Override
public void run() {
        test.k();
        test.g();
    }
}

public class ObjectSynchronized {

public static void main(String[] args) throws Exception{
        TestSynchronized test = new TestSynchronized();
        Run1 run1 = new Run1(test);
        Run2 run2 = new Run2(test);
        ExecutorService exec = Executors.newCachedThreadPool();

        exec.execute(run1);
        exec.execute(run2);

        exec.shutdown();
    }

}

運行這個程式的結果如下：

In function k
In function f()
In function k
In function f(), sleeping
In function g()
In function g(), sleeping

    這說明，當一個線程A的某個對象擷取鎖進入一個同步方法之後，另一個線程B的同一個對象就不能再調用這個對象上的任何synchronized方法，直到線程A的那個對象釋放鎖。

    這也就是為什麼wait()在調用時要釋放對象已擷取的鎖的原因：如果線程A因為等待某個條件而調用wait()，如果它不釋放已經獲得的同步鎖，那麼其他線程可能就無法改變這個對象當中的某些條件（因為無法再進入這個對象的同步方法中），導致死結的發生。