Java併發編程之synchronized

Java語言的關鍵字，當它用來修飾一個方法或者一個代碼塊的時候，能夠保證在同一個時間，只有一個線程可以進行操作。多線程的同步機制對資源進行加鎖，同步用以解決多個線程同時訪問時可能出現的問題。

• 對於普通同步方法，鎖是當前實例對象。
• 對於靜態同步方法，鎖是當前類的Class對象。
• 對於同步方法塊，鎖是Synchonized括號裏配置的對象。

當一個線程試圖訪問同步代碼塊時，它首先必須得到鎖，退出或拋出異常時必須釋放鎖。

1.是否使用synchronized關鍵字的不同

package com.itmyhome;

class Thread1 extends Thread {
    private Example example;

    public Thread1(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute();
    }
}


class Example {
    public synchronized void execute() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Hello: " + i);
        }
    }
}


public class ThreadTest {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Example example = new Example();
        Thread t1 = new Thread1(example);
        Thread t2 = new Thread1(example);
        t1.start();
        t2.start();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44

是否在execute()方法前加上synchronized關鍵字，這個例子程序的執行結果會有很大的不同。 
如果不加synchronized關鍵字，則兩個線程同時執行execute()方法，輸出是兩組併發的。 
如果加上synchronized關鍵字，則會先輸出一組0到9，然後再輸出下一組，說明兩個線程是順次執行的。

2.多個方法的多線程情況

將程序改動一下，Example類中再加入一個方法execute2()。之後再寫一個線程類Thread2，Thread2中的run()方法執行的是execute2()。Example類中的兩個方法都是被synchronized關鍵字修飾的。

package com.itmyhome;

class Thread1 extends Thread {
    private Example example;

    public Thread1(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute();
    }
}


class Thread2 extends Thread {
    private Example example;

    public Thread2(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute2();
    }
}


class Example {
    public synchronized void execute() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Hello: " + i);
        }
    }

    public synchronized void execute2() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Hello: " + i);
        }
    }
}


public class ThreadTest {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Example example = new Example();
        Thread t1 = new Thread1(example);
        Thread t2 = new Thread2(example);
        t1.start();
        t2.start();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70

如果一個對象有多個synchronized方法，某一時刻某個線程已經進入到了某個synchronized方法，那麼在該方法沒有執行完畢前，其他線程是無法訪問該對象的任何synchronized方法的。

結論：

當synchronized關鍵字修飾一個方法的時候，該方法叫做同步方法。Java中的每個對象都有一個鎖(lock)，或者叫做監視器(monitor)，當一個線程訪問某個對象的synchronized方法時，將該對象上鎖，其他任何線程都無法再去訪問該對象的synchronized方法了(這裏是指所有的同步方法，而不僅僅是同一個方法)，直到之前的那個線程執行方法完畢後（或者是拋出了異常），纔將該對象的鎖釋放掉，其他線程纔有可能再去訪問該對象的synchronized方法。注意這時候是給對象上鎖，如果是不同的對象，則各個對象之間沒有限制關係。 
嘗試在代碼中構造第二個線程對象時傳入一個新的Example對象，則兩個線程的執行之間沒有什麼制約關係。

3.考慮靜態的同步方法

當一個synchronized關鍵字修飾的方法同時又被static修飾，之前說過，非靜態的同步方法會將對象上鎖，但是靜態方法不屬於對象，而是屬於類，它會將這個方法所在的類的Class對象上鎖。

一個類不管生成多少個對象，它們所對應的是同一個Class對象。

package com.itmyhome;

class Thread1 extends Thread {
    private Example example;

    public Thread1(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute();
    }
}


class Thread2 extends Thread {
    private Example example;

    public Thread2(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute2();
    }
}


class Example {
    // 靜態同步
    public synchronized static void execute() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Hello: " + i);
        }
    }

    public synchronized static void execute2() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Hello: " + i);
        }
    }
}


public class ThreadTest {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Example example = new Example();

        // 此處即便傳入不同的對象，靜態方法同步仍然不允許多個線程同時執行
        Example example2 = new Example();
        Thread t1 = new Thread1(example);
        Thread t2 = new Thread2(example2);
        t1.start();
        t2.start();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74

所以如果是靜態方法的情況(execute()和execute2()都加上static關鍵字)，即便是向兩個線程傳入不同的Example對象，這兩個線程仍然是互相制約的，必須先執行完一個，再執行下一個。

結論：

如果某個synchronized方法是static的，那麼當線程訪問該方法時，它鎖的並不是synchronized方法所在的對象，而是synchronized方法所在的類所對應的Class對象。Java中，無論一個類有多少個對象，這些對象會對應唯一一個Class對象，因此當線程分別訪問同一個類的兩個對象的兩個static，synchronized方法時，它們的執行順序也是順序的，也就是說一個線程先去執行方法，執行完畢後另一個線程纔開始。

4. synchronized塊

synchronized塊寫法：

synchronized(object)
{　 

}

• 1
• 2
• 3
• 4

• 1
• 2
• 3
• 4

表示線程在執行的時候會將object對象上鎖。（注意這個對象可以是任意類的對象，也可以使用this關鍵字）。 
這樣就可以自行規定上鎖對象。

package com.itmyhome;

class Thread1 extends Thread {
    private Example example;

    public Thread1(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute();
    }
}


class Thread2 extends Thread {
    private Example example;

    public Thread2(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute2();
    }
}


class Example {
    private Object object = new Object();

    public void execute() {
        synchronized (object) {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("Hello: " + i);
            }
        }
    }

    public void execute2() {
        synchronized (object) {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("Hello: " + i);
            }
        }
    }
}


public class ThreadTest {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Example example = new Example();
        Thread t1 = new Thread1(example);
        Thread t2 = new Thread2(example);
        t1.start();
        t2.start();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76

例子程序4所達到的效果和例子程序2的效果一樣，都是使得兩個線程的執行順序進行，而不是併發進行，當一個線程執行時，將object對象鎖住，另一個線程就不能執行對應的塊。

synchronized方法實際上等同於用一個synchronized塊包住方法中的所有語句，然後在synchronized塊的括號中傳入this關鍵字。當然，如果是靜態方法，需要鎖定的則是class對象。

可能一個方法中只有幾行代碼會涉及到線程同步問題，所以synchronized塊比synchronized方法更加細粒度地控制了多個線程的訪問，只有synchronized塊中的內容不能同時被多個線程所訪問，方法中的其他語句仍然可以同時被多個線程所訪問（包括synchronized塊之前的和之後的）。

注意：被synchronized保護的數據應該是私有的。

結論：

• synchronized方法是一種粗粒度的併發控制，某一時刻，只能有一個線程執行該synchronized方法；
• synchronized塊則是一種細粒度的併發控制，只會將塊中的代碼同步，位於方法內、synchronized塊之外的其他代碼是可以被多個線程同時訪問到的。

轉載出處：http://blog.csdn.net/itmyhome1990/article/details/75334571