【多線程】 線程同步的幾種方式

爲什麼要使用同步？ 

    java容許多線程併發控制，當多個線程同時操做一個可共享的資源變量時（如數據的增刪改查）， 

    將會致使數據不許確，相互之間產生衝突，所以加入同步鎖以免在該線程沒有完成操做以前，被其餘線程的調用， 

    從而保證了該變量的惟一性和準確性。

 

 

 

1.同步方法 

    即有synchronized關鍵字修飾的方法。 

    因爲java的每一個對象都有一個內置鎖，當用此關鍵字修飾方法時， 

    內置鎖會保護整個方法。在調用該方法前，須要得到內置鎖，不然就處於阻塞狀態。

 

 

    代碼如： 

    public synchronized void save(){}

 

 

   注： synchronized關鍵字也能夠修飾靜態方法，此時若是調用該靜態方法，將會鎖住整個類

 

 

 

2.同步代碼塊 

    即有synchronized關鍵字修飾的語句塊。 

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

 

 

    代碼如： 

    synchronized(object){ 

    }

 

 

    注：同步是一種高開銷的操做，所以應該儘可能減小同步的內容。 

    一般沒有必要同步整個方法，使用synchronized代碼塊同步關鍵代碼便可。 

     

    代碼實例： 

    

 

複製代碼

package com.xhj.thread;

 

    /**

     * 線程同步的運用

     * 

     * @author XIEHEJUN

     * 

     */

    public class SynchronizedThread {

 

        class Bank {

 

            private int account = 100;

 

            public int getAccount() {

                return account;

            }

 

            /**

             * 用同步方法實現

             * 

             * @param money

             */

            public synchronized void save(int money) {

                account += money;

            }

 

            /**

             * 用同步代碼塊實現

             * 

             * @param money

             */

            public void save1(int money) {

                synchronized (this) {

                    account += money;

                }

            }

        }

 

        class NewThread implements Runnable {

            private Bank bank;

 

            public NewThread(Bank bank) {

                this.bank = bank;

            }

 

            @Override

            public void run() {

                for (int i = 0; i < 10; i++) {

                    // bank.save1(10);

                    bank.save(10);

                    System.out.println(i + "帳戶餘額爲：" + bank.getAccount());

                }

            }

 

        }

 

        /**

         * 創建線程，調用內部類

         */

        public void useThread() {

            Bank bank = new Bank();

            NewThread new_thread = new NewThread(bank);

            System.out.println("線程1");

            Thread thread1 = new Thread(new_thread);

            thread1.start();

            System.out.println("線程2");

            Thread thread2 = new Thread(new_thread);

            thread2.start();

        }

 

        public static void main(String[] args) {

            SynchronizedThread st = new SynchronizedThread();

            st.useThread();

        }

 

    }

複製代碼

     

3.使用特殊域變量(volatile)實現線程同步

 

    a.volatile關鍵字爲域變量的訪問提供了一種免鎖機制， 

    b.使用volatile修飾域至關於告訴虛擬機該域可能會被其餘線程更新， 

    c.所以每次使用該域就要從新計算，而不是使用寄存器中的值 

    d.volatile不會提供任何原子操做，它也不能用來修飾final類型的變量 

    

    例如： 

        在上面的例子當中，只需在account前面加上volatile修飾，便可實現線程同步。 

    

    代碼實例： 

    

 

複製代碼

      //只給出要修改的代碼，其他代碼與上同

        class Bank {

            //須要同步的變量加上volatile

            private volatile int account = 100;

 

            public int getAccount() {

                return account;

            }

            //這裏再也不須要synchronized 

            public void save(int money) {

                account += money;

            }

        ｝

複製代碼

 

    注：多線程中的非同步問題主要出如今對域的讀寫上，若是讓域自身避免這個問題，則就不須要修改操做該域的方法。 

    用final域，有鎖保護的域和volatile域能夠避免非同步的問題。 

    

4.使用重入鎖實現線程同步

 

    在JavaSE5.0中新增了一個java.util.concurrent包來支持同步。 

    ReentrantLock類是可重入、互斥、實現了Lock接口的鎖， 

    它與使用synchronized方法和快具備相同的基本行爲和語義，而且擴展了其能力

 

 

    ReenreantLock類的經常使用方法有：

 

        ReentrantLock() : 建立一個ReentrantLock實例 

        lock() : 得到鎖 

        unlock() : 釋放鎖 

    注：ReentrantLock()還有一個能夠建立公平鎖的構造方法，但因爲能大幅度下降程序運行效率，不推薦使用 

        

    例如： 

        在上面例子的基礎上，改寫後的代碼爲: 

        

    代碼實例： 

    

 

複製代碼

//只給出要修改的代碼，其他代碼與上同

        class Bank {

            

            private int account = 100;

            //須要聲明這個鎖

            private Lock lock = new ReentrantLock();

            public int getAccount() {

                return account;

            }

            //這裏再也不須要synchronized 

            public void save(int money) {

                lock.lock();

                try{

                    account += money;

                }finally{

                    lock.unlock();

                }

                

            }

        ｝

複製代碼

          

    注：關於Lock對象和synchronized關鍵字的選擇： 

        a.最好兩個都不用，使用一種java.util.concurrent包提供的機制， 

            可以幫助用戶處理全部與鎖相關的代碼。 

        b.若是synchronized關鍵字能知足用戶的需求，就用synchronized，由於它能簡化代碼 

        c.若是須要更高級的功能，就用ReentrantLock類，此時要注意及時釋放鎖，不然會出現死鎖，一般在finally代碼釋放鎖 

        

5.使用局部變量實現線程同步 

    若是使用ThreadLocal管理變量，則每個使用該變量的線程都得到該變量的副本， 

    副本之間相互獨立，這樣每個線程均可以隨意修改本身的變量副本，而不會對其餘線程產生影響。

 

 

 

    ThreadLocal 類的經常使用方法

 

 

 

    ThreadLocal() : 建立一個線程本地變量 

    get() : 返回此線程局部變量的當前線程副本中的值 

    initialValue() : 返回此線程局部變量的當前線程的"初始值" 

    set(T value) : 將此線程局部變量的當前線程副本中的值設置爲value

 

 

 

    例如： 

        在上面例子基礎上，修改後的代碼爲： 

        

    代碼實例： 

        

 

複製代碼

//只改Bank類，其他代碼與上同

        public class Bank{

            //使用ThreadLocal類管理共享變量account

            private static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){

                @Override

                protected Integer initialValue(){

                    return 100;

                }

            };

            public void save(int money){

                account.set(account.get()+money);

            }

            public int getAccount(){

                return account.get();

            }

        }

複製代碼

    注：ThreadLocal與同步機制 

        a.ThreadLocal與同步機制都是爲了解決多線程中相同變量的訪問衝突問題。 

        b.前者採用以"空間換時間"的方法，後者採用以"時間換空間"的方式