一、引言

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

二、為什麼要執行緒同步

因為當我們有多個執行緒要同時訪問一個變數或物件時，如果這些執行緒中既有讀又有寫操作時，就會導致變數值或物件的狀態出現混亂，從而導致程式異常。舉個例子，如果一個銀行賬戶同時被兩個執行緒操作，一個取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. }  

SyncThreadTest.java

1. package threadTest;  
2. publicclass SyncThreadTest {  
3.     publicstaticvoid 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.     

    相關推薦

    多執行緒有幾種實現方法?同步有幾種實現方法?

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

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

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

    Map執行緒安全幾種實現方法

    如果需要使 Map 執行緒安全，大致有這麼四種方法：  1、使用 synchronized 關鍵字，程式碼如下 synchronized(anObject) {  　　value = map.get(key); } 2、使用 JDK1.5提供的鎖（j

    執行緒的三種實現方法

    執行緒的三種實現方法：（1）繼承 Thread 類，重寫run()方法； （2）實現 Runnable 介面，重寫run() 方法； （3）實現 Callable 介面，重寫call()方法； 方式一：  繼承Thread類 public class MyThreadDemo {

    多執行緒的四種實現方法

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

    java執行緒的幾種常用方法

    join() Thread物件方法，用於使當前執行緒和後面的程式碼同步，使當前執行緒內操作執行完成後再執行後面的指令 wait() Thread物件方法，使當前執行緒進入等待狀態，等待狀態的執行緒不會去競爭資源 sleep() Thread類方法，使當前執行緒休眠指定時間

    執行緒有兩種實現方法的具體區別

    Java中有兩種實現多執行緒的方式。一是直接繼承Thread類，二是實現Runnable介面。那麼這兩種實現多執行緒的方式在應用上有什麼區別呢？ 第一種方式：使用Runnable介面建立執行緒第二種方式：直接繼承Thread類建立物件使用Runnable介面建立執行緒1.可

    4. 執行緒同步幾種方式

    執行緒同步的方式主要有以下四種:臨界區（Critical Section）、互斥量（Mutex）、訊號量（Semaphore）、事件（Event）的區別。 他們的主要區別和特點如下： 1）臨界區：通過對多執行緒的序列化來訪問公共資源或一段程式碼，速度快，適合控制資料訪問。在任意時刻只允許一個執行緒對共

    iOS 執行緒同步幾種方式

    多執行緒同步目的有以下幾個方面：第一，對一段程式碼的執行進行保護，如果同時執行一段程式碼，中間的臨時變數可能會互相干擾造成結果不對；第二，對資源的保護，多個執行緒執行不同的程式碼，但是可能涉及同一個資源；第三，訊息傳遞，一個執行緒通知另外一個執行緒發生了一件事。

    多執行緒的兩種實現方法

    package thread; //繼承方式： /*class Demo2 extends Thread {private String name;Demo2(String name){super(name);this.name=name;}public void run(

    Linux kernel多執行緒的幾種實現

    驅動開發中常常會啟動幾個核心執行緒，在整個驅動生命週期期間執行某些操作，比如USB驅動的控制執行緒，一直等待SCSI命令，沒有命令的話睡眠，有命令的話就喚醒執行緒，解析執行相關的命令。還有USB驅動中的掃描執行緒，如果有新的裝置連線到USB匯流排，則會啟動掃描過程，平時時

    Android 執行緒 thread 兩種實現方法！

    這篇文章中有三點需要提前說明一下， 一： 在android中有兩種實現執行緒thread的方法： 一種是，擴充套件java.lang.Thread類 另一種是，實現Runnable介面 二： Thread類代表執行緒類，它的兩個最主要的方法是： run()——包含執

    多執行緒同步和互斥有哪幾種實現方法？

    執行緒間的同步方法大體可分為兩類：使用者模式和核心模式。顧名思義，核心模式就是指利用系統核心物件的單一性來進行同步，使用時需要切換核心態與使用者態，而使用者模式就是不需要切換到核心態，只在使用者態完成操作。使用者模式下的方法有：原子操作（例如一個單一的全域性變數），臨界區。核

    執行緒同步的幾種實現方法

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

    JAVA之多執行緒概念及其幾種實現方法優劣分析

    1. 多執行緒 程式：指令集，靜態的概念 程序：作業系統調動程式，是程式的一次動態執行過程，動態的概念 執行緒：在程序內的多條執行路徑 Ps：單核的話程序都是虛擬模擬出來的，多核處理器才可以執行真正的多執行緒 單核通過CPU排程時間片實現虛擬模擬的多執行緒，比如執行main函式和GC在底層就是多執行

    多執行緒，兩種實現方式(繼承Thread，實現Runnable介面)，設定獲取名字，同步程式碼塊、方法，死鎖

    1.多執行緒的引入(瞭解) 1.什麼是執行緒 執行緒是程式執行的一條路徑, 一個程序中可以包含多條執行緒 多執行緒併發執行可以提高程式的效率, 可以同時完成多項工作 2.多執行緒的應用場景 紅蜘蛛同時共享螢幕給多個電腦 迅雷開啟多條執行緒一起下載 Q

    Android的執行緒詳解（幾種實現方法及區別）

    一、Android執行緒的定義和特點     1.什麼是執行緒： 執行緒是一種輕量級程序，大多數情況下用於執行非同步操作。在一個Android 程式開始執行的時候，會單獨啟動一個程序，同時會產生一個UIThread執行緒（main執行緒）。一個Android 程式預設情況

    多線程有幾種實現方法?同步有幾種實現方法?(被問到)

    所有 正在 () read 異常 同步 -h 競爭 sync 多線程有兩種實現方法，分別是繼承Thread類與實現Runnable接口 同步的實現方面有兩種，分別是synchronized,wait與notify wait():使一個線程處於等待狀態，並且釋放所持有的對象的

    設計模式之單例模式【內附物件例項化幾種方式、實現執行緒安全幾種方式】

    繼續來複習常用的設計模式-單例模式，順便回憶一下執行緒安全的幾種實現方式。 一、什麼是單例模式 單例模式，簡單常用的一種設計模式，也很好的體現了程式碼控制物件在記憶體數量的一種方式，主要分2種實現方式： ①餓漢式，執行緒安全 ②懶漢式，執行緒不安全（新增鎖機制，可以實現執行緒安全）

    多執行緒(一)：建立執行緒的幾種方法

    概括來說就是兩種：1、繼承Thread類，重寫run方法，然後start。不推薦這種，因為java的單繼承特性。 2、Thread類的建構函式中可以接受Runnable任務，所以只要是Runnable例項就可以作為引數給Thread 一般有兩種建立Runnable例項的方法（1）實現Runn