一、引言

前幾天面試，被大師虐殘了，好多基礎知識必須得重新拿起來啊。閒話不多說，進入正題。

二、為什麼要執行緒同步

因為當我們有多個執行緒要同時訪問一個變數或物件時，如果這些執行緒中既有讀又有寫操作時，就會導致變數值或物件的狀態出現混亂，從而導致程式異常。舉個例子，如果一個銀行賬戶同時被兩個執行緒操作，一個取100塊，一個存錢100塊。假設賬戶原本有0塊，如果取錢執行緒和存錢執行緒同時發生，會出現什麼結果呢？取錢不成功，賬戶餘額是100.取錢成功了，賬戶餘額是0.那到底是哪個呢？很難說清楚。因此多執行緒同步就是要解決這個問題。

三、不同步時的程式碼

Bank.java

1. package threadTest;  
2. /** 
3.  * @author ww
    
4.  * 
5.  */
6. publicclass Bank {  
7.     privateint count =0;//賬戶餘額
8.     //存錢
9.     publicvoid addMoney(int money){  
10.         count +=money;  
11.         System.out.println(System.currentTimeMillis()+"存進："+money);  
12.     }  
13.     //取錢
14.     publicvoid subMoney(int money){  
15.         if(count-money < 0){  
16.             System.out.println("餘額不足"
    );  
17.             return;  
18.         }  
19.         count -=money;  
20.         System.out.println(+System.currentTimeMillis()+"取出："+money);  
21.     }  
22.     //查詢
23.     publicvoid lookMoney(){  
24.         System.out.println("賬戶餘額："+count);  
25.     }  
26. }  

1. package threadTest;  
2. publicclass SyncThreadTest {  
3.     public
   staticvoid main(String args[]){  
4.         final Bank bank=new Bank();  
5.         Thread tadd=new Thread(new Runnable() {  
6.             @Override
7.             publicvoid run() {  
8.                 // TODO Auto-generated method stub
9.                 while(true){  
10.                     try {  
11.                         Thread.sleep(1000);  
12.                     } catch (InterruptedException e) {  
13.                         // TODO Auto-generated catch block
14.                         e.printStackTrace();  
15.                     }  
16.                     bank.addMoney(100);  
17.                     bank.lookMoney();  
18.                     System.out.println("\n");  
19.                 }  
20.             }  
21.         });  
22.         Thread tsub = new Thread(new Runnable() {  
23.             @Override
24.             publicvoid run() {  
25.                 // TODO Auto-generated method stub
26.                 while(true){  
27.                     bank.subMoney(100);  
28.                     bank.lookMoney();  
29.                     System.out.println("\n");  
30.                     try {  
31.                         Thread.sleep(1000);  
32.                     } catch (InterruptedException e) {  
33.                         // TODO Auto-generated catch block
34.                         e.printStackTrace();  
35.                     }     
36.                 }  
37.             }  
38.         });  
39.         tsub.start();  
40.         tadd.start();  
41.     }  
42. }  

程式碼很簡單，我就不解釋了，看看執行結果怎樣呢？截取了其中的一部分，是不是很亂，有寫看不懂。

1. 餘額不足  
2. 賬戶餘額：0
3. 餘額不足  
4. 賬戶餘額：100
5. 1441790503354存進：100
6. 賬戶餘額：100
7. 1441790504354存進：100
8. 賬戶餘額：100
9. 1441790504354取出：100
10. 賬戶餘額：100
11. 1441790505355存進：100
12. 賬戶餘額：100
13. 1441790505355取出：100
14. 賬戶餘額：100

四、使用同步時的程式碼

（1）同步方法：

即有synchronized關鍵字修飾的方法。 由於java的每個物件都有一個內建鎖，當用此關鍵字修飾方法時，內建鎖會保護整個方法。在呼叫該方法前，需要獲得內建鎖，否則就處於阻塞狀態。

修改後的Bank.java

1. package threadTest;  
2. /** 
3.  * @author ww 
4.  * 
5.  */
6. publicclass Bank {  
7.     privateint count =0;//賬戶餘額
8.     //存錢
9.     publicsynchronizedvoid addMoney(int money){  
10.         count +=money;  
11.         System.out.println(System.currentTimeMillis()+"存進："+money);  
12.     }  
13.     //取錢
14.     publicsynchronizedvoid subMoney(int money){  
15.         if(count-money < 0){  
16.             System.out.println("餘額不足");  
17.             return;  
18.         }  
19.         count -=money;  
20.         System.out.println(+System.currentTimeMillis()+"取出："+money);  
21.     }  
22.     //查詢
23.     publicvoid lookMoney(){  
24.         System.out.println("賬戶餘額："+count);  
25.     }  
26. }  

1. 餘額不足  
2. 賬戶餘額：0  
3. 相關推薦

   java多執行緒同步5種方法

   一、引言前幾天面試，被大師虐殘了，好多基礎知識必須得重新拿起來啊。閒話不多說，進入正題。二、為什麼要執行緒同步因為當我們有多個執行緒要同時訪問一個變數或物件時，如果這些執行緒中既有讀又有寫操作時，就會導致變數值或物件的狀態出現混亂，從而導致程式異常。舉個例子，如果一個銀行賬戶

   Java——實現Java多執行緒的三種方法

   Java虛擬機器允許應用程式併發地執行多個執行緒。在Java語言中，多執行緒的實現一般有以下3種方法，其中前兩種是最常用的方法。 1.繼承Thread類，重寫run（）方法 Thread本質上也是實現了Runnable介面的一個例項，它代表一個執行緒的例項。並且，啟動執行緒的唯一方法就是通過

   Java多執行緒同步的五種方法

   一、引言 前幾天面試，被大師虐殘了，好多基礎知識必須得重新拿起來啊。閒話不多說，進入正題。 二、為什麼要執行緒同步 因為當我們有多個執行緒要同時訪問一個變數或物件時，如果這些執行緒中既有讀又有寫操作時，就會導致變數值或物件的狀態出現混亂，從而導致程式異常。舉個例

   Java 多執行緒同步的五種方法 [轉]

   程式碼很簡單，我就不解釋了，看看執行結果怎樣呢？截取了其中的一部分，是不是很亂，有寫看不懂。 餘額不足   賬戶餘額：0 餘額不足   賬戶餘額：100 1441790503354存進：100   賬戶餘額：100 1441790504354存進：100   賬戶餘額：100 144179050

   Java 多執行緒同步的五種方法

   一、引言 前幾天面試，被大師虐殘了，好多基礎知識必須得重新拿起來啊。閒話不多說，進入正題。 二、為什麼要執行緒同步 因為當我們有多個執行緒要同時訪問一個變數或物件時，如果這些執行緒中既有讀又有寫操作時，就會導致變數值或物件的狀態出現混亂，從而導致程式異常。舉個例子，

   java執行緒同步5種方式

    java允許多執行緒併發控制，當多個執行緒同時操作一個可共享的資源變數時（如資料的增刪改查），      將會導致資料不準確，相互之間產生衝突，因此加入同步鎖以避免在該執行緒沒有完成操作之前，被其他執行緒的呼叫，      從而保證了該變數的唯一性和準確性。 1

   java多執行緒的幾種實現方法

             方法一：繼承Thread類，覆蓋方法run（）， public class MyThread extends Thread { int count= 1, number; public MyThread(int num) { number = num;

   java -- 多執行緒的兩種建立方法

   什麼是程序？　什麼是執行緒？ 個人感覺比較好理解 怎麼建立多執行緒？ 建立多執行緒有兩種方式：　1， 繼承 Thread 類。        2， 實現 Runnable 介面 先來看看第一種方法

   Java建立多執行緒的三種方法

   Java多執行緒實現方式主要有三種：繼承Thread類、實現Runnable介面、使用ExecutorService、Callable、Future實現有返回結果的多執行緒。其中前兩種方式執行緒執行完後都沒有返回值，只有最後一種是帶返回值的。1、繼承Thread類實現多執行緒

   JAVA基礎-實現多執行緒的四種方法

   Java多執行緒實現方式主要有四種：繼承Thread類、實現Runnable介面、實現Callable介面通過FutureTask包裝器來建立Thread執行緒、使用ExecutorService、Callable、Future實現有返回結果的多執行緒。其中前兩種方式執行緒執行完後都沒有返回值，後兩種是帶返回

   Java多執行緒同步的幾種方式

   當多個執行緒同時訪問一個資源時，非常容易出現安全問題。因此需要採用同步機制來解決這種問題。java主要提供了3種實現同步機制的方法： 1）、synchronized關鍵字 synchronized有兩種用法（synchronized方法和synchronized塊） syn

   Java----實現多執行緒的兩種方法及其區別

   1.建立多執行緒的兩種方式 1.通過繼承Thread類實現多執行緒 class MyThread extends Thread{ //重寫run方法 public void run(){ } } //測試類：建立執行緒

   Java 多執行緒 join和interrupt 方法

   簡述： 使用Java多執行緒中join和interrupt函式 《Java程式設計思想》 P669 ~ P670 一個執行緒可以再其他執行緒上呼叫join()方法，其效果是等待一段時間直到第二個執行緒結束才繼續執行。 如果某個執行緒在另一個執行緒t上呼叫t.join(), 此

   java 多執行緒同步

               執行緒屬性： 1.執行緒優先順序， 　　優先順序高度依賴於系統，不要讓程式的正確性依賴於優先順序。預設情況子執行緒會繼承父執行緒的優先順序。 2.守護執行緒， 　　唯一用途是為其他執行緒提供服務，當只剩

   java建立執行緒的四種方法（轉）

   java中建立執行緒的四種方法以及區別 Java使用Thread類代表執行緒，所有的執行緒物件都必須是Thread類或其子類的例項。Java可以用四種方式來建立執行緒，如下所示： 1）繼承Thread類建立執行緒 2）實現Runnable介面建立執行緒 3）使用Callable和Future建立執行緒

   java 多執行緒的一種實現方式

   private ThreadPoolExecutor threadPoolExecutor; /** * 獲取執行緒池 * @return */ private ThreadPoolExecutor getThreadPoolExecutor(){

   實現java多執行緒的3種方式，99%人沒用過第3種

   實現多執行緒的3種方式 1、繼承Thread類 看jdk原始碼可以發現，Thread類其實是實現了Runnable介面的一個例項，繼承Thread類後需要重寫run方法並通過start方法啟動執行緒。 繼承Thread類耦合性太強了，因為java只能單繼承，所以不利

   建立多執行緒的兩種方法

   建立執行緒的方法： 一種方法是將類宣告為 Thread 的子類。該子類應重寫 Thread 類的 run 方法。接下來可以分配並啟動該子類的例項。 public class MyThread extends Thread{

   java 建立執行緒的三種方法

   在java中使用Thread類代表執行緒，所有的執行緒物件都必須是Thread類或其子類的例項，建立執行緒有三種方式： 1.通過繼承Thread類建立執行緒； 2.通過實現Runnable介面建立執行緒； 3.通過使用Callable和Future建立執行緒。 建立執行緒demo

   java多執行緒：5.1 鎖-基礎

   什麼是鎖 提到多執行緒，立馬就有人說加鎖，什麼是鎖，為什麼加鎖？ 鎖：從字面意義，什麼東西加了鎖，那麼就只有有鑰匙的人才能使用，多執行緒中的鎖，也是這個意思。 為什麼加鎖：當單執行緒的時候，無論訪問什麼資源，都不需要考慮鎖的問題，但是當多個執行緒訪問同一個資源，就會發生很多千奇百怪的