java多線程synchronized塊同步方法

2019-11-14 14:55:46

字體：大中小

來源：轉載

供稿：網友

synchronized關鍵字又稱同步鎖

當方法執行完后，會自動釋放鎖，只有一個線程能進入此方法

看看以下的各種例子對synchronized的詳細解釋

1.是否加synchronized關鍵字的不同

 1 public class ThreadTest { 2  3     public static void main(String[] args) { 4         Example example = new Example(); 5  6         Thread t1 = new Thread1(example); 7         Thread t2 = new Thread1(example); 8         t1.start(); 9         t2.start();10     }11 }12 13 class Example {14     public synchronized void excute() {15         for (int i = 0; i < 5; ++i) {16             try {17                 Thread.sleep(1000);18             } catch (InterruptedException e) {19                 e.PRintStackTrace();20             }21             System.out.println("excute:" + i);22         }23 24     }25 26 }27 28 class Thread1 extends Thread {29     private Example example;30 31     public Thread1(Example example) {32         this.example = example;33     }34 35     @Override36     public void run() {37         example.excute();38     }39 }

加了synchronized關鍵字的輸出結果如下

會先輸出一組0-4，接著再輸出下一組，兩個線程順序執行

excute:0
excute:1
excute:2
excute:3
excute:4
excute:0
excute:1
excute:2
excute:3
excute:4

沒加synchronized關鍵字的輸出結果如下

兩個線程同時執行excute方法，同時并發的

excute:0
excute:0
excute:1
excute:1
excute:2
excute:2
excute:3
excute:3
excute:4
excute:4

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

 1 public class ThreadTest { 2  3     public static void main(String[] args) { 4         Example example = new Example(); 5  6         Thread t1 = new Thread1(example); 7         Thread t2 = new Thread2(example); 8         t1.start(); 9         t2.start();10     }11 }12 13 class Example {14     public synchronized void excute() {15         for (int i = 0; i < 5; ++i) {16             try {17                 Thread.sleep(1000);18             } catch (InterruptedException e) {19                 e.printStackTrace();20             }21             System.out.println("excute:" + i);22         }23     }24     public synchronized void excute1() {25         for (int i = 0; i < 5; ++i) {26             try {27                 Thread.sleep(1000);28             } catch (InterruptedException e) {29                 e.printStackTrace();30             }31             System.out.println("excute1:" + i);32         }33     }34 35 }36 37 class Thread1 extends Thread {38     private Example example;39 40     public Thread1(Example example) {41         this.example = example;42     }43 44     @Override45     public void run() {46         example.excute();47     }48 }49 50 class Thread2 extends Thread {51     private Example example;52 53     public Thread2(Example example) {54         this.example = example;55     }56 57     @Override58     public void run() {59         example.excute1();60     }61 }

執行結果如下

同樣是順序執行，執行完一個線程再執行另一個線程

excute:0
excute:1
excute:2
excute:3
excute:4
excute1:0
excute1:1
excute1:2
excute1:3
excute1:4

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

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

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

說明：

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

結論：

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

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

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

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

3.靜態的同步方法

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

 1 public class ThreadTest { 2  3     public static void main(String[] args) { 4         Example example = new Example(); 5         Example example2 = new Example(); 6         Thread t1 = new Thread1(example); 7         Thread t2 = new Thread2(example2); 8         t1.start(); 9         t2.start();10     }11 }12 13 class Example {14     public synchronized static void excute() {15         for (int i = 0; i < 5; ++i) {16             try {17                 Thread.sleep(1000);18             } catch (InterruptedException e) {19                 e.printStackTrace();20             }21             System.out.println("excute:" + i);22         }23     }24     public synchronized static void excute1() {25         for (int i = 0; i < 5; ++i) {26             try {27                 Thread.sleep(1000);28             } catch (InterruptedException e) {29                 e.printStackTrace();30             }31             System.out.println("excute1:" + i);32         }33     }34 35 }36 37 class Thread1 extends Thread {38     private Example example;39 40     public Thread1(Example example) {41         this.example = example;42     }43 44     @Override45     public void run() {46         example.excute();47     }48 }49 50 class Thread2 extends Thread {51     private Example example;52 53     public Thread2(Example example) {54         this.example = example;55     }56 57     @Override58     public void run() {59         example.excute1();60     }61 }

執行結果如下

excute:0
excute:1
excute:2
excute:3
excute:4
excute1:0
excute1:1
excute1:2
excute1:3
excute1:4

如果沒有static修飾符，兩個線程分別傳入不同的對象，則會同時并發執行

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

結論：

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

4.synchronized塊

synchronized(object)

{　

}

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

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

 1 public class ThreadTest { 2  3     public static void main(String[] args) { 4         Example example = new Example(); 5         Thread t1 = new Thread1(example); 6         Thread t2 = new Thread2(example); 7         t1.start(); 8         t2.start(); 9     }10 }11 12 class Example {13     public void excute() {14         synchronized (this) {15             for (int i = 0; i < 5; ++i) {16                 try {17                     Thread.sleep(1000);18                 } catch (InterruptedException e) {19                     e.printStackTrace();20                 }21                 System.out.println("excute:" + i);22             }23         }24         25     }26     public void excute1() {27         synchronized (this) {28             for (int i = 0; i < 5; ++i) {29                 try {30                     Thread.sleep(1000);31                 } catch (InterruptedException e) {32                     e.printStackTrace();33                 }34                 System.out.println("excute1:" + i);35             }36         }37         38     }39 40 }41 42 class Thread1 extends Thread {43     private Example example;44 45     public Thread1(Example example) {46         this.example = example;47     }48 49     @Override50     public void run() {51         example.excute();52     }53 }54 55 class Thread2 extends Thread {56     private Example example;57 58     public Thread2(Example example) {59         this.example = example;60     }61 62     @Override63     public void run() {64         example.excute1();65     }66 }

執行結果如下

excute:0
excute:1
excute:2
excute:3
excute:4
excute1:0
excute1:1
excute1:2
excute1:3
excute1:4

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

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

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

結論：

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

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

原創文章來源:http://m.survivalescaperooms.com/mengdd/archive/2013/02/16/2913806.html

上一篇：JPA學習(3)JPAAPI

下一篇：圈復雜度