java 多執行緒 –同步

多執行緒的同步

為什麼引入同步機制

多執行緒為什麼要採用同步機制，因為不同的執行緒有自己的棧，棧中可能引用了多個物件，而多個執行緒可能引用到了堆中的同一個或多個物件，而執行緒的棧記憶體當中的資料只是臨時資料，最終都是要重新整理到堆中的物件記憶體，這裡的重新整理並不是最終的狀態一次性重新整理，而是在程式執行的過程中隨時重新整理（肯定有固定的機制，暫不考慮），也許在一個執行緒中被應用物件中的某一個方法執行到一半的時候就將該物件的變數狀態重新整理到了堆的物件記憶體中，那麼再從多執行緒角度來看，當多個執行緒對同一個物件中的同一個變數進行讀寫的時候，就會出現類似資料庫中的併發問題。

假設銀行裡某一使用者賬戶有1000元，執行緒A讀取到1000，並想取出這1000元，並且在棧中修改成了0但還沒有重新整理到堆中，執行緒B也讀取到1000，此時賬戶重新整理到銀行系統中，則賬戶的錢變成了0，這個時候也想去除1000，再次重新整理到行系統中，賬號的錢變成0，這個時候A，B都取出1000元，但是賬戶只有1000，顯然出現了問題。針對上述問題，假設我們新增了同步機制，那麼就可以很容易的解決。

怎樣解決這種問題呢，線上程使用一個資源時為其加鎖即可。訪問資源的第一個執行緒為其加上鎖以後，其他執行緒便不能再使用那個資源，除非被解鎖。

程式碼：

package com.java.test;

/**
 * Created by xiaofandiy03 on 2018/4/14.
 */
public class     DrawMoneyTest {
    public static void main(String[] args)
    {
        Bank bank = new Bank();

        Thread t1 = new MoneyThread(bank);// 從銀行取錢
        Thread t2 = new MoneyThread(bank);// 從取款機取錢

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

    }
}
class Bank{
    private int money =1000;
    public int getMoney(int number)
    {
        if(number <0)
        {
            return -1;
        }else if(number >money) {
            return  -2;
        }else if(money <0)
        {
            return -3;
        }else {
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
            money-=number;
        System.out.println("Left Money :" +money);
        return  number;
    }
}
class MoneyThread extends Thread
{
    private Bank bank;

    public MoneyThread(Bank bank)
    {
        this.bank = bank;
    }

    @Override
    public void run()
    {
        System.out.println(bank.getMoney(1000));
    }
}複製程式碼

競態條件

執行緒同步方法

同步方法：

即有synchronized關鍵字修飾方法。悠悠java每個物件都有一個內建鎖，放用關鍵字修飾方法時，內建所會保護整個方法。在呼叫該方法錢，獲得內建鎖，否則就處於阻塞狀態。

class Bank{
    private int money =1000;
    public synchronized int getMoney(int number)
    {
        if(number <0)
        {
            return -1;
        }else if(number >money) {
            return  -2;
        }else if(money <0)
        {
            return -3;
        }else {
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
            money-=number;
        System.out.println("Left Money :" +money);
        return  number;
    }
}複製程式碼

 synchronized關鍵字也可以修飾靜態方法，此時如果呼叫該靜態方法，將會鎖住整個類

同步程式碼塊

即有synchronized關鍵字修飾的語句塊。被該關鍵字修飾的語句塊會自動被加上內建鎖，從而實現同步

class Bank{
    private int money =1000;
    public  int getMoney(int number)
    {
        synchronized (this) {
            if (number < 0) {
                return -1;
            } else if (number > money) {
                return -2;
            } else if (money < 0) {
                return -3;
            } else {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            money -= number;
        }
        System.out.println("Left Money :" +money);
        return  number;
    }
}
複製程式碼

同步是一種高開銷的操作，因此應該儘量減少同步的內容。通常沒有必要同步整個方法，使用synchronized程式碼塊同步關鍵程式碼即可。

使用重入鎖實現執行緒同步

在JavaSE5.0中新增了一個java.util.concurrent包來支援同步。ReentrantLock類是可重入、互斥、實現了Lock介面的鎖， 它與使用synchronized方法和快具有相同的基本行為和語義，並且擴充套件了其能力。
ReenreantLock類的常用方法有：
ReentrantLock() : 建立一個ReentrantLock例項
lock() : 獲得鎖
unlock() : 釋放鎖
注：ReentrantLock()還有一個可以建立公平鎖的構造方法，但由於能大幅度降低程式執行效率，不推薦使用 

當一個共享變數被volatile修飾的時候，他會保證變數被修改之後立馬在記憶體中更新，另一執行緒在取值時候需要去記憶體中讀取新的值。

volatile可以保證變數的記憶體可見性，但是不能保證原子性，對於b++這個操作來說，並不是一步到位的，而是分好幾步的，讀取白那兩，定義常量1，變數b加1，結果同步到記憶體。雖然在每一步中獲取的都是變數的最新值，但是沒有保證b++的原子性，自然無法做到執行緒安全。

使用區域性變數實現執行緒同步

如果使用ThreadLocal管理變數，則每一個使用該變數的執行緒都獲得該變數的副本，副本之間相互獨立，這樣每一個執行緒都可以隨意修改自己的變數副本，而不會對其他執行緒產生影響。現在明白了吧，原來每個執行緒執行的都是一個副本，也就是說存錢和取錢是兩個賬戶，知識名字相同而已。所以就會發生上面的效果。