Java 多線程（六） synchronized關鍵字詳解，synchronized關鍵字

Java 多線程（六） synchronized關鍵字詳解，synchronized關鍵字
Java 多線程（六） synchronized關鍵字詳解

　　多線程的同步機制對資源進行加鎖，使得在同一個時間，只有一個線程可以進行操作，同步用以解決多個線程同時訪問時可能出現的問題。

　　同步機制可以使用synchronized關鍵字實現。

　　當synchronized關鍵字修飾一個方法的時候，該方法叫做同步方法。

　　當synchronized方法執行完或發生異常時，會自動釋放鎖。

　　下面通過一個例子來對synchronized關鍵字的用法進行解析。　　

 1.是否使用synchronized關鍵字的不同例子程式1

　　public class ThreadTest
　　{
　　　　public static void main(String[] args)
　　　　{
　　　　　　Example example = new Example();

　　　　　　Thread t1 = new Thread1(example);
　　　　　　Thread t2 = new Thread1(example);

　　　　　　t1.start();
　　　　　　t2.start();
　　　　}

　　}

 

　　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);
　　　　　　}
　　　　}

　　}

 

　　class Thread1 extends Thread
　　{
　　　　private Example example;

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

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

　　}

 

　　是否在execute()方法前加上synchronized關鍵字，這個例子程式的執行結果會有很大的不同。

　　如果不加synchronized關鍵字，則兩個線程同時執行execute()方法，輸出是兩組並發的。

　　如果加上synchronized關鍵字，則會先輸出一組0到9，然後再輸出下一組，說明兩個線程是順次執行的。

 

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

　　將程式改動一下，Example類中再加入一個方法execute2()。

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

例子程式2

public class ThreadTest{    public static void main(String[] args)    {        Example example = new Example();        Thread t1 = new Thread1(example);        Thread t2 = new Thread2(example);        t1.start();        t2.start();    }}class Example{    public synchronized void execute()    {        for (int i = 0; i < 20; ++i)        {            try            {                Thread.sleep((long) Math.random() * 1000);            }            catch (InterruptedException e)            {                e.printStackTrace();            }            System.out.println("Hello: " + i);        }    }    public synchronized void execute2()    {        for (int i = 0; i < 20; ++i)        {            try            {                Thread.sleep((long) Math.random() * 1000);            }            catch (InterruptedException e)            {                e.printStackTrace();            }            System.out.println("World: " + i);        }    }}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();    }}

 　　如果去掉synchronized關鍵字，則兩個方法並發執行，並沒有相互影響。

　　但是如例子程式中所寫，即便是兩個方法：

　　執行結果永遠是執行完一個線程的輸出再執行另一個線程的。　　

　　說明：

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

　　結論：

　　當synchronized關鍵字修飾一個方法的時候，該方法叫做同步方法。

　　Java中的每個對象都有一個鎖（lock），或者叫做監視器（monitor），當一個線程訪問某個對象的synchronized方法時，將該對象上鎖，其他任何線程都無法再去訪問該對象的synchronized方法了（這裡是指所有的同步方法，而不僅僅是同一個方法），直到之前的那個線程執行方法完畢後（或者是拋出了異常），才將該對象的鎖釋放掉，其他線程才有可能再去訪問該對象的synchronized方法。

　　注意這時候是給對象上鎖，如果是不同的對象，則各個對象之間沒有限制關係。

　　嘗試在代碼中構造第二個線程對象時傳入一個新的Example對象，則兩個線程的執行之間沒有什麼制約關係。

 3.考慮靜態同步方法

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

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

例子程式3

public class ThreadTest{    public static void main(String[] args)    {        Example example = new Example();        Thread t1 = new Thread1(example);        // 此處即便傳入不同的對象，靜態方法同步仍然不允許多個線程同時執行        example = new Example();        Thread t2 = new Thread2(example);        t1.start();        t2.start();    }}class Example{    public synchronized static void execute()    {        for (int i = 0; i < 20; ++i)        {            try            {                Thread.sleep((long) Math.random() * 1000);            }            catch (InterruptedException e)            {                e.printStackTrace();            }            System.out.println("Hello: " + i);        }    }    public synchronized static void execute2()    {        for (int i = 0; i < 20; ++i)        {            try            {                Thread.sleep((long) Math.random() * 1000);            }            catch (InterruptedException e)            {                e.printStackTrace();            }            System.out.println("World: " + i);        }    }}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();    }}

 

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

 

　　結論：

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

 

4. synchronized塊

　　synchronized塊寫法：

　　synchronized(object)

　　{　     

　　}

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

　　這樣就可以自行規定上鎖對象。　

　

例子程式4

public class ThreadTest{    public static void main(String[] args)    {        Example example = new Example();        Thread t1 = new Thread1(example);        Thread t2 = new Thread2(example);        t1.start();        t2.start();    }}class Example{    private Object object = new Object();    public void execute()    {        synchronized (object)        {            for (int i = 0; i < 20; ++i)            {                try                {                    Thread.sleep((long) Math.random() * 1000);                }                catch (InterruptedException e)                {                    e.printStackTrace();                }                System.out.println("Hello: " + i);            }        }    }    public void execute2()    {        synchronized (object)        {            for (int i = 0; i < 20; ++i)            {                try                {                    Thread.sleep((long) Math.random() * 1000);                }                catch (InterruptedException e)                {                    e.printStackTrace();                }                System.out.println("World: " + i);            }        }    }}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();    }}

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

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

　　

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

　　注意：被synchronized保護的資料應該是私人的。

　　結論：

　　synchronized方法是一種粗粒度的並發控制，某一時刻，只能有一個線程執行該synchronized方法；

　　synchronized塊則是一種細粒度的並發控制，只會將塊中的代碼同步，位於方法內、synchronized塊之外的其他代碼是可以被多個線程同時訪問到的。

 JDK 5.0的並發包

　　使用synchronized關鍵字解決線程的同步問題會帶來一些執行效率上的問題。

　　JDK1.4及之前是無法避免這些問題的。

　　JDK 5.0引入了這樣一個包：java.util.concurrent：

　　http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-frame.html

　　專門解決這一問題。

　　限於篇幅，這裡不再介紹。

 參考資料

　　聖思園張龍老師Java SE系列視頻教程。

 

來源：http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html