Java中多線程訪問沖突的解決方式

當時用多線程訪問同一個資源時，非常容易出現線程安全的問題，例如當多個線程同時對一個數據進行修改時，會導致某些線程對數據的修改丟失。因此需要采用同步機制來解決這種問題。

第一種 同步方法

第二種 同步代碼塊

第三種 使用特殊成員變量（volatile 成員變量）實現線程同步（前提是對成員變量的操作是原子操作）

第四種 使用Lock接口（java.util.concurrent.locks包）

第五種 使用線程局部變量（thread-local）解決多線程對同一變量的訪問沖突，而不能實現同步（ThreadLocal類）

第六種 使用阻塞隊列實現線程同步（java.util.concurrent包）

第七種 使用原子變量實現線程同步 （java.util.concurrent.atomic包）

---

 

第一種 同步方法

同步方法即使用 synchronized關鍵字修飾的方法。在Java語言中，每個對象都有一個內置的對象鎖與之相關聯，該鎖會保護整個方法，即對象在任何時候只允許被一個線程所擁有，當一個線程調用對象的一段synchronized代碼時，首先需要獲得這個鎖，然后去執行相應的代碼，執行結束，釋放鎖。synchronized關鍵字也可以以修飾靜態方法，此時如果調用該靜態方法，將會鎖住整個類。

synchronized關鍵字主要有兩種用法：synchronized方法和synchronized塊。此外該關鍵字還可以作用於靜態方法、類或某個實例，但這都對程序的效率有很大的影響。

給一個方法增加synchronized關鍵字之后就可以使它成為同步方法，這個方法可以是靜態方法和非靜態方法，但是不能是抽象類的抽象方法，也不能是接口中的抽象方法。

synchronized方法，在方法的聲明前加入synchronized關鍵字。例如

package com.test.multiThread;

public class Bank {
    private int account = 0;

    public int getAccount(){
        return account;
    }
    // 同步方法
    public synchronized void save(int money){
        this.account += money;
    }
}

=================================

package com.test.multiThread;

public class MyThread implements Runnable {
    private Bank bank;
    public MyThread(Bank bank){
        this.bank = bank;
    }
    @Override
    public void run() {
        bank.save(1);
        //bank.save01(1);
        //bank.save02(1);
    }
}

=================================

package com.test.multiThread;

import java.util.ArrayList;

public class MultiThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Bank bank = new Bank();
        System.out.println(bank.getAccount());
        ArrayList<Thread> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++){
            list.add(new Thread(new MyThread(bank)));
        }
        for (Thread thread: list){
            thread.start();
        }
        for (Thread thread: list){
            thread.join();
        }
        System.out.println(bank.getAccount());
    }
}

只要把多線程訪問的資源的操作放到multiThreadAccess方法中，就能夠保證這個方法在同一時刻只能被一個線程訪問，從而保證了多線程訪問的安全性。然而當一個方法的方法體規模非常大時，把該方法聲明為synchronized會大大影響程序的執行效率。為了提高程序的執行效率，Java語言提供了synchronized塊。

第二種 同步代碼塊

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

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

可以把任意的代碼塊聲明為synchronized，也可以制定上鎖的對象，有非常高的靈活性。用法如下

package com.test.multiThread;

public class Bank {
    private int account = 0;

    public int getAccount(){
        return account;
    }
    // 同步代碼塊
    public void save(int money){
        synchronized (this){
            this.account += money;
        }
    }
}

===============================

package com.test.multiThread;

public class MyThread implements Runnable {
    private Bank bank;
    public MyThread(Bank bank){
        this.bank = bank;
    }
    @Override
    public void run() {
        bank.save(1);
    }
}


===============================

package com.test.multiThread;

import java.util.ArrayList;

public class MultiThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Bank bank = new Bank();
        System.out.println(bank.getAccount());
        ArrayList<Thread> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++){
            list.add(new Thread(new MyThread(bank)));
        }
        for (Thread thread: list){
            thread.start();
        }
        for (Thread thread: list){
            thread.join();
        }
        System.out.println(bank.getAccount());
    }
}

當使用synchronized來修飾某個共享資源的時候，如果線程Thread01在執行synchronized代碼，另外一個線程Thread02也要同時執行同一對象的統一synchronized代碼時，線程Thread02將要等到線程Thread01執行成后才能繼續執行。在這種情況下，可以使用wait()方法和notify()方法。

在synchronized代碼被執行期間，線程可以調用對象的wait()方法，釋放對象鎖，進入等待狀態，並且可以調用notify()方法或者notifyAll()方法通知正在等待的而其他線程，notify()喚醒一個線程（等待隊列中的第一個線程），並允許它去獲得鎖，而notifyAll()方法喚醒所有等待這個對象的線程，並允許它們去競爭獲得鎖。

第三種 使用特殊成員變量（volatile 成員變量）實現線程同步（前提是對成員變量的操作是原子操作）

volatile是一個類型修飾符，被設計用來修飾被不同線程訪問和修飾的變量。當變量沒有被volatile修飾時，線程讀取數據時可能會從緩存中去讀取，如果其他線程修改了該變量，則無法讀取到修改后的數據。當變量被volatile修飾時，線程每次使用時都會直接到內存中提取，而不會利用緩存，從而保證了數據的同步。

volatile關鍵字主要目的是放置編譯器對代碼的優化，使得每次使用數據的時候都從內存里提取，而不是緩存，保證獲得的數據是最新被修改的數據。但是volatile不能保證操作的原子性，一般不能替代synchronized代碼塊，除非對變量的操作是原子操作的情況下才可以使用volatile。

① volatile關鍵字為成員變量的訪問提供了一種免鎖機制，但要保證對成員變量的操作是原子操作的情況下才能使用

② volatile關鍵字相當於告訴虛擬機該成員變量可能會被其他線程修改

③ 每次使用被volatile修飾的成員變量都要從內存提取，重新計算，而不會使用寄存機器中的值

④ volatile不會提供任何原子操作，不能保證線程安全

⑤ volatile不能用來修飾final類型的變量

⑥ 使用volatile會降低程序的執行效率

Java中原子性保證：Java內存模型只保證了基本讀取和復制是原子性操作，如果要實現更大范圍操作的原子性，可以通過synchronized和Lock保證任一時刻只有一個線程執行該代碼，那么自然就不存在原子性問題了，從而保證了原子性。

Java中可見性保證：synchronized和Lock、volatile三種，推薦使用synchronized方式，volatile有局限，適合某個特定場合。

第四種 使用Lock接口（java.util.concurrent.locks包）

JDK5新增了一個java.util.concurrent.locks包來支持同步。該包中提供了Lock接口以及它的一個實現類ReentrantLock（重入鎖）

Lock接口也可以用來實現多線程的同步，其提供了如下方法來實現多線程的同步

public abstract void lock()  // 以阻塞方式來獲得鎖，即如果獲得了鎖就立即返回，如果其他線程持有鎖，當前線程等待，直到獲取鎖后返回。當前線程會一直處於阻塞狀態，且會忽略interrupt（）方法
public abstract boolean tryLock()  // 以非阻塞的方式獲得鎖，即嘗試性的去獲取鎖，如果獲得鎖就返回true，否則返回false
public abstract boolean tryLock(long time, TimeUnit unit)  // 如果在給定時間內獲得鎖，返回true，否則返回false
public abstract void lockInterruptibly  // 如果獲得鎖，則立即返回，如果沒有獲得鎖，則當前線程會處於休眠狀態，直到獲得鎖，或者當前線程被其他線程中斷（會收到InterruptedException異常）。
public abstract void unlock  // 釋放鎖

ReentrantLock類的構造方法

public ReentrantLock()  // 創建一個ReentrantLock實例
public ReentrantLock(boolean fair)  // 創建公平鎖的構造方法，但由於能大幅度降低程序運行效率，不推薦使用

使用Lock接口實現多線程同步的例子

package com.test.multiThread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Bank {
    private int account = 0;
    private Lock lock = new ReentrantLock();  // 聲明這個重入鎖

    public int getAccount(){
        return account;
    }
    public void save(int money){
        lock.lock();  // 以阻塞方式獲得鎖
        try {
            account += money;
        } finally {
            lock.unlock();  // 釋放鎖
        }
    }
}

=============================

package com.test.multiThread;

public class MyThread implements Runnable {
    private Bank bank;
    public MyThread(Bank bank){
        this.bank = bank;
    }
    @Override
    public void run() {
        bank.save(1);
    }
}

=============================

package com.test.multiThread;

import java.util.ArrayList;

public class MultiThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Bank bank = new Bank();
        System.out.println(bank.getAccount());
        ArrayList<Thread> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++){
            list.add(new Thread(new MyThread(bank)));
        }
        for (Thread thread: list){
            thread.start();
        }
        for (Thread thread: list){
            thread.join();
        }
        System.out.println(bank.getAccount());
    }
}

第五種 使用線程局部變量（thread-local）解決多線程對同一變量的訪問沖突，而不能實現同步 （ThreadLocal類）

public class ThreadLocal<T>
extends Object

如果使用ThreadLocal來管理變量，則每一個使用該變量的線程都會獲得該變量的副本，副本之間相互獨立，這樣每一個線程都可以隨意修改自己的變量副本，而不會對其他線程產生影響。所以對於同線程對共享變量的操作互不影響。

public class ThreadLocal<T>
extends Object
常用方法
public ThreadLocal()  // 構造方法
public T get()  // 返回次線程局部變量的當前線程副本中的值
public void set(T value)  // 將次線程局部變量的當前線程副本中的值設置為value
protected T initialValue()  // 返回次線程局部變量的當前線程的初始值
public void remove()  // 

Thread-local與同步機制的比較：

1）兩者都是為了解決多線程中相同變量的訪問沖突問題

2）Thread-local采用“空間換時間”方法，同步機制采用“時間換空間”的方式

使用Thread-local的例子

package com.test.multiThread;

public class Bank {
    private static ThreadLocal<Integer> account = ThreadLocal.withInitial(() -> 0);
    public void save(int money){
        account.set(account.get() + money);
    }
    public int getAccount(){
        return account.get();
    }
}

============================

package com.test.multiThread;

public class MyThread implements Runnable {
    private Bank bank;
    public MyThread(Bank bank){
        this.bank = bank;
    }
    @Override
    public void run() {
        for (int i = 1; i < 10; i++){
            bank.save(i);
        }
        System.out.println("Thread-local中的值: " + bank.getAccount());
    }
}

============================

package com.test.multiThread;

import java.util.ArrayList;

public class MultiThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Bank bank = new Bank();
        System.out.println("原始值：" + bank.getAccount());
        ArrayList<Thread> list = new ArrayList<>();
        for (int i = 0; i < 10; i++){
            list.add(new Thread(new MyThread(bank)));
        }
        for (Thread thread: list){
            thread.start();
        }
        for (Thread thread: list){
            thread.join();
        }
        System.out.println("原始值：" + bank.getAccount());
    }
}

結果：改變的只是線程中變量的值，線程結束后Thread-local變量就銷毀了

第六種 使用阻塞隊列實現線程同步（java.util.concurrent包）

在JDK5提供的java.util.concurrent包中的 Class LinkedBlockingQueue<E> 可以實現線程的同步。

LinkedBlockingQueue<E>是一個基於已連接節點的，范圍任意的blocking queue。其常用方法如下：

public LinkedBlockingQueue()  //創建一個容量為Interger.MAX_VALUE的LinkedBlockingQueue
public int size()  // 返回隊列中的元素個數
public void put(E e) throws InterruptedException  // 在隊尾添加一個元素，如果隊列滿則阻塞
public E take() throws InterruptedException  // 返回並移除對首元素，如果隊列空則阻塞

使用阻塞隊列實現生產者-消費者。總的來說生產者的速度和消費者的速度相同，但是因為阻塞隊列的緣故，不需要控制阻塞，當阻塞對列滿的時候，生產者線程就會被阻塞，直到不再滿；反之亦然，當消費者線程多於生產者線程時，消費者速度大於生產者速度，當隊列為空時，就會阻塞消費者線程，直到隊列非空。

package com.test.multiThread;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class WorkDesk {
    private BlockingQueue<String> desk = new LinkedBlockingQueue<>(10);
    public void washDish() throws InterruptedException{
        desk.put("盤子");
    }
    public String useDish() throws InterruptedException{
        return desk.take();
    }
}

=================================

package com.test.multiThread;

public class Producer implements Runnable {
    private String producerName;
    private WorkDesk workDesk;

    public Producer(String producerName, WorkDesk workDesk){
        this.producerName = producerName;
        this.workDesk = workDesk;
    }
    @Override
    public void run() {
        try {
            while (true) {
                workDesk.washDish();
                System.out.println(producerName + "洗好一個盤子");
                Thread.sleep(1000);
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

=================================

package com.test.multiThread;

public class Consumer implements Runnable {
    private String consumerName;
    private WorkDesk workDesk;

    public Consumer(String consumerName, WorkDesk workDesk){
        this.consumerName = consumerName;
        this.workDesk = workDesk;
    }

    @Override
    public void run() {
        try {
            while (true) {
                workDesk.useDish();
                System.out.println(consumerName + "使用一個盤子");
                Thread.sleep(1000);
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

=================================

package com.test.multiThread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestBlockingQueue {
    public static void main(String[] args){
        WorkDesk workDesk = new WorkDesk();

        ExecutorService service = Executors.newCachedThreadPool();
        Producer producer01 = new Producer("生產者-1-", workDesk);
        Producer producer02 = new Producer("生產者-2-", workDesk);

        Consumer consumer01 = new Consumer("消費者-1-", workDesk);
        Consumer consumer02 = new Consumer("消費者-2-", workDesk);

        service.submit(producer01);
        service.submit(producer02);
        service.submit(consumer01);
        service.submit(consumer02);
    }
}

 

 

第七種 使用原子變量實現線程同步（java.util.concurrent.atomic包）

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

原子操作就是指將讀取變量值、修改變量值、保存變量值看成一個整體來操作，即這幾步要么同時完成，要么都不完成。

在JDK5中提供的java.util.concurrent.atomic包中提供了創建原子類型變量的工具類，使用這些工具類能夠簡化線程同步。

package com.test.multiThread;

import java.util.concurrent.atomic.AtomicInteger;

public class Bank {
    private AtomicInteger account = new AtomicInteger(0);  // 創建具有給定初始值的新的AtomicInteger

    public int getAccount(){
        return account.get();  // 獲取當前值
    }

    public void save(int money){
        account.addAndGet(money);  // 以原子方式將給定值與當前值相加
    }
}

================================

package com.test.multiThread;

public class MyThread implements Runnable {
    private Bank bank;
    public MyThread(Bank bank){
        this.bank = bank;
    }
    @Override
    public void run() {
        bank.save(1);
    }
}

================================

package com.test.multiThread;

import java.util.ArrayList;

public class MultiThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        Bank bank = new Bank();
        System.out.println("原始值：" + bank.getAccount());
        ArrayList<Thread> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++){
            list.add(new Thread(new MyThread(bank)));
        }
        for (Thread thread: list){
            thread.start();
        }
        for (Thread thread: list){
            thread.join();
        }
        System.out.println("線程執行完后：" + bank.getAccount());
    }
}