網上看到一個題目，題目是這樣：Java多執行緒，啟動四個執行緒，兩個執行加一，另外兩個執行減一。

針對該問題寫了一個程式，測試通過，如下：

class Sync {  
	static int count = 0;
	  
    public void add() {  
        synchronized (Sync.class) {  
            System.out.println("test開始..");  
            count++;
            System.out.println("count = "+count);
            System.out.println("test結束..");  
        }  
    }  
    
    public void sub() {  
        synchronized (Sync.class) {  
            System.out.println("test開始..");  
            count--;
            System.out.println("count = "+count);
            System.out.println("test結束..");  
        }  
    }  
}  
  
class MyThread extends Thread {
	int operation = 0;
    public MyThread(int operation) {
		this.operation = operation;
	}


	public void run() { 
        Sync sync = new Sync();  
        if(operation==0){
        	sync.sub();
        }else if(operation==1){
        	sync.add();  
        }
        
    }  
}  
  
public class Main {  
  
    public static void main(String[] args) {  
    	//t1,t2做加法
        Thread t1 = new MyThread(1);  
        Thread t2 = new MyThread(1);  
        //t3,t4做減法
        Thread t3 = new MyThread(0);  
        Thread t4 = new MyThread(0);  
        t1.start();  
        t2.start();  
        t3.start();  
        t4.start();  
      
    }  
}  
 

輸出結果：

test開始..
count = 1
test結束..
test開始..
count = 0
test結束..
test開始..
count = 1
test結束..
test開始..
count = 0
test結束..

分析：執行緒t1,t2執行加法操作，執行緒t3,t4執行減法操作。在該程式中有兩個需要注意的點：

1.變數count必須定義為靜態型別static，因為如果不是定義成static,則雖然4個執行緒鎖住的是同一個物件，但是他們操作的count確實從屬於不同的sync例項，因為每個執行緒的sync是執行緒內部建立的，而不是從外界統一注入，由於每個執行緒操作的count分屬不同sync例項，導致結果具有隨機性。count定義為static後，多個執行緒操作的count為Sync類的靜態變數count，共享，結果為0.
2.這種實現的方式是一種比較低效的方式，分析程式碼，add()方法和sub()方法的鎖物件也是相同的，即有一個執行緒在執行add(）方法時，其他執行緒除了不能執行同步方法add()以外，sub()方法也不能執行，這是因為使用的全域性鎖，一個同步方法執行時，其他所有的同步方法都不能執行。