【java】為何要使用同步？ 關於線程同步(7種方式)

為何要使用同步？

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.前者採用以"空間換時間"的方法，後者採用以"時間換空間"的方法

6.使用阻塞隊列實現線程同步

前面5種同步方式都是在底層實現的線程同步，但是我們在實際開發當中，應當盡量遠離底層結構。
使用javaSE5.0版本中新增的java.util.concurrent包將有助於簡化開發。
本小節主要是使用LinkedBlockingQueue<E>來實現線程的同步
LinkedBlockingQueue<E>是一個基於已串連節點的，範圍任意的blocking queue。
隊列是先進先出的順序（FIFO），關於隊列以後會詳細講解~

LinkedBlockingQueue 類常用方法
LinkedBlockingQueue() : 建立一個容量為Integer.MAX_VALUE的LinkedBlockingQueue
put(E e) : 在隊尾添加一個元素，如果隊列滿則阻塞
size() : 返回隊列中的元素個數
take() : 移除並返回隊頭元素，如果隊列空則阻塞

代碼執行個體：
實現商家生產商品和買賣商品的同步

 1 package com.xhj.thread; 2  3 import java.util.Random; 4 import java.util.concurrent.LinkedBlockingQueue; 5  6 /** 7  * 用阻塞隊列實現線程同步 LinkedBlockingQueue的使用 8  *  9  * @author XIEHEJUN10  * 11  */12 public class BlockingSynchronizedThread {13     /**14      * 定義一個阻塞隊列用來儲存生產出來的商品15      */16     private LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>();17     /**18      * 定義生產商品個數19      */20     private static final int size = 10;21     /**22      * 定義啟動線程的標誌，為0時，啟動生產商品的線程；為1時，啟動消費商品的線程23      */24     private int flag = 0;25 26     private class LinkBlockThread implements Runnable {27         @Override28         public void run() {29             int new_flag = flag++;30             System.out.println("啟動線程 " + new_flag);31             if (new_flag == 0) {32                 for (int i = 0; i < size; i++) {33                     int b = new Random().nextInt(255);34                     System.out.println("生產商品：" + b + "號");35                     try {36                         queue.put(b);37                     } catch (InterruptedException e) {38                         // TODO Auto-generated catch block39                         e.printStackTrace();40                     }41                     System.out.println("倉庫中還有商品：" + queue.size() + "個");42                     try {43                         Thread.sleep(100);44                     } catch (InterruptedException e) {45                         // TODO Auto-generated catch block46                         e.printStackTrace();47                     }48                 }49             } else {50                 for (int i = 0; i < size / 2; i++) {51                     try {52                         int n = queue.take();53                         System.out.println("消費者買去了" + n + "號商品");54                     } catch (InterruptedException e) {55                         // TODO Auto-generated catch block56                         e.printStackTrace();57                     }58                     System.out.println("倉庫中還有商品：" + queue.size() + "個");59                     try {60                         Thread.sleep(100);61                     } catch (Exception e) {62                         // TODO: handle exception63                     }64                 }65             }66         }67     }68 69     public static void main(String[] args) {70         BlockingSynchronizedThread bst = new BlockingSynchronizedThread();71         LinkBlockThread lbt = bst.new LinkBlockThread();72         Thread thread1 = new Thread(lbt);73         Thread thread2 = new Thread(lbt);74         thread1.start();75         thread2.start();76 77     }78 79 }

註：BlockingQueue<E>定義了阻塞隊列的常用方法，尤其是三種添加元素的方法，我們要多加註意，當隊列滿時：

　　add()方法會拋出異常

　　offer()方法返回false

　　put()方法會阻塞

7.使用原子變數實現線程同步

需要使用線程同步的根本原因在於對普通變數的操作不是原子的。

那麼什麼是原子操作呢？
原子操作就是指將讀取變數值、修改變數值、儲存變數值看成一個整體來操作
即-這幾種行為要麼同時完成，要麼都不完成。
在java的util.concurrent.atomic包中提供了建立了原子類型變數的工具類，
使用該類可以簡化線程同步。
其中AtomicInteger 表可以用原子方式更新int的值，可用在應用程式中(如以原子方式增加的計數器)，
但不能用於替換Integer；可擴充Number，允許那些處理機遇數字類的工具和工具 + 生產力進行統一訪問。
AtomicInteger類常用方法：
AtomicInteger(int initialValue) : 建立具有給定初始值的新的AtomicInteger
addAddGet(int dalta) : 以原子方式將給定值與當前值相加
get() : 擷取當前值
代碼執行個體：
只改Bank類，其餘代碼與上面第一個例子同

 1 class Bank { 2         private AtomicInteger account = new AtomicInteger(100); 3  4         public AtomicInteger getAccount() { 5             return account; 6         } 7  8         public void save(int money) { 9             account.addAndGet(money);10         }11     }

補充--原子操作主要有：
　　對於引用變數和大多數原始變數(long和double除外)的讀寫操作；
　　對於所有使用volatile修飾的變數(包括long和double)的讀寫操作。

相關文章：

關於Java線程同步和同步方法的詳解

詳解Java多線程編程中的線程同步方法