1、執行緒安全問題的出現

在大多數的多執行緒應用程式中，兩個或者兩個以上的執行緒需要共享對同一資料的存取。這時可能發生多執行緒同時修改共享變數的情況，以在銀行取錢來說，可以分為一下幾個步驟：
1. 輸入卡號和密碼，系統判斷是否匹配並有效
2. 使用者輸入支取金額
3. 系統判斷賬戶可用餘額是否足夠支取
4. 如果滿足支取條件則取款並更新餘額，否則取款失敗
我們使用兩個執行緒來同時模擬取款操作：

public class Account {

        private String acctNo;
        private double balance;

        //getter/setter
 

        //有參構造方法
}

public class GetMoney extends Thread {

    private Account account;
    private double tranAmt; //支取金額

    public GetMoney(String name, Account account, double tranAmt) {
        super(name);
        this.account = account;
        this.tranAmt = tranAmt;
    }

    @Override
    public
 
 void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (account.getBalance() >= tranAmt) {
            //更新餘額
            account.setBalance(account.getBalance() - tranAmt);
            System.out.println(getName() + " 餘額為 ： "
 
 + account.getBalance());
        } else {
            System.out.println(getName() + "賬戶餘額不足，支取失敗！");
        }

    }

    public static void main(String[] args) {
        Account account = new Account("3303214000000007654", 1000);
        new GetMoney("A", account, 400).start();
        new GetMoney("B", account, 400).start();
    }

}

較大概率出現如下輸出結果：

B 餘額為 ： 200.0
A 餘額為 ： 200.0

執行結果並不是我們希望的：

A 餘額為 ： 600.0
b 餘額為 ： 200.0

在多執行緒的環境下，如果一個共享資源（取款操作中的賬戶餘額balance）被多個執行緒同時訪問，可能會出現意向不到的情況。特定場景的分析見我的另一篇文章執行緒安全問題

出現這類問題的原因大多數是因為單個操作的顆粒度較小，例如取款中：①、獲取賬戶餘額；②、判斷餘額是否充足；③、更新餘額。這明顯是三個獨立的操作。可以使用同步機制將顆粒度較小的原子操作包裹成顆粒度較大的操作。

2、同步程式碼塊

為了解決執行緒安全問題，Java引入同步程式碼：

synchronized(obj){
    //需要同步的操作
}

任何時刻只能有一個執行緒能夠獲得obj資源並進入同步程式碼塊進行操作，當同步程式碼塊執行完畢後，該執行緒會釋放obj資源。通常使用多執行緒共享的資源充當同步程式碼塊中的“鎖物件”。 例如取錢的例子中應該使用賬戶account充當“鎖物件”。我們將上例修改為：

@Override
    public void run() {
        synchronized (account) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (account.getBalance() >= tranAmt) {
                //更新餘額
                account.setBalance(account.getBalance() - tranAmt);
                System.out.println(getName() + " 餘額為 ： " + account.getBalance());
            } else {
                System.out.println(getName() + "賬戶餘額不足，支取失敗！");
            }
        }

    }

使用synchronized將取款的邏輯包裹起來，任何執行緒進入run方法時都會試圖獲取account“鎖物件”，如果某個執行緒獲取到了“鎖物件”，它就可以執行取款操作，其餘執行緒由於不能獲取“鎖物件”，只能等待那個執行緒執行完同步程式碼塊中的程式碼後釋放鎖。
新增同步程式碼塊後程序總會輸出：

A 餘額為 ： 600.0
B 餘額為 ： 200.0

3、同步方法

同步方法就是使用synchronized關鍵字來修飾某個方法，對於同步方法而言，無需顯示地宣告“鎖物件”，它的“鎖物件”就是物件本身（this）。

package com.xiaopeng.multthread;

public class AccountSyn {

    private String acctNo;
    private double balance;

    public AccountSyn(String acctNo, double balance) {
        this.acctNo = acctNo;
        this.balance = balance;
    }

    public String getAcctNo() {
        return acctNo;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    //同步方法
    public synchronized void draw(double tranAmt) {
        if (balance >= tranAmt) {
            System.out.println(Thread.currentThread().getName() + " 取款 ：" + tranAmt + "元");
            balance -= tranAmt;
            System.out.println(Thread.currentThread().getName() + " 餘額為 ：" + balance + "元");
        } else {
            System.out.println("賬戶餘額不足");
        }
    }

}

使用同步方法可以實現執行緒安全的類，它們具有以下特徵：

1. 該類的每個物件都可以被多執行緒訪問
2. 任意執行緒呼叫該物件的任意方法都可以得到正確的輸出
3. 執行緒呼叫之後，該物件依舊儲存正常狀態

增加同步的注意點：

1. 程式碼同步後，同一時間點只能有一個執行緒對其中的任務進行訪問，這會明顯降低程式的執行效率，所以應該只對必要的邏輯進行同步操作。
2. 如果某段程式碼會執行在單執行緒和多執行緒的環境中，那麼應該提供兩種版本同時保證單執行緒中的效率以及多執行緒中的安全。例如 StringBuffer 保證了多執行緒中的安全性， StringBuilder 保證了單執行緒中的高效率。