緒論

一：執行緒安全問題

1.1 提出問題

1.2 不安全的原因

1.2.1 原子性

1.2.2 代碼“優化”

二：如何解決執行緒不安全的問題

2.1 通過synchronized關鍵字

2.2 volatile

三：wait和notify關鍵字

3.1 wait方法

3.2 notify方法

3.3 wait和sleep對比（面試常考）

四：多執行緒案例

4.1 餓漢模式單執行緒

4.2 懶漢模式單執行緒

4.3 懶漢模式多執行緒低性能版

4.4懶漢模式-多執行緒版-二次判斷-性能高

總結

緒論

上期介紹了多執行緒的概念、優勢、創建方法以及幾個常用的關鍵字，有了之前的基礎過后，我們來討論討論執行緒安全問題以及其他執行緒進階知識，

一：執行緒安全問題

1.1 提出問題

首先，給大家看一下這個代碼：

public class yy1 {
    private static class Counter {
        private long n = 0;
        public void increment() {
            n++;
        }
        public void decrement() {
            n--;
        }
        public long value() {
            return n;
        }
    }
    public static void main(String[] args) throws InterruptedException {
        final int COUNT = 1000_0000;
        Counter counter = new Counter();
        Thread thread = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                counter.increment();
            }
        }, "李四");
        thread.start();
        for (int i = 0; i < COUNT; i++) {
            counter.decrement();
        }
        thread.join();
// 期望最終結果應該是 0
        System.out.println(counter.value());
    }
}

大家看結果：

大家觀察下是否適用多執行緒的現象是否一致？同時嘗試思考下為什么會有這樣的現象發生呢？

想給出一個執行緒安全的確切定義是復雜的，但我們可以這樣認為：

如果多執行緒環境下代碼運行的結果是符合我們預期的，即在單執行緒環境應該的結果，則說這個程式是執行緒安全的，

1.2 不安全的原因

1.2.1 原子性

舉個簡單的例子，當我i們買票的時候，如果車站剩余票數大于0，就可以買，反之，買完一張票后，車站的票數也會自動減一，假設出現這種情況，兩個人同時來買票，只剩最后一張票，前面那個人把最后一張票買了，但是短時間內票數還沒減一也就是清零，這時另外一個人看到還有一張票，于是提交訂單，但是其實已經沒有多余的票了，那么問題就來了，這時我們引入原子性：

我們把一段代碼想象成一個房間，每個執行緒就是要進入這個房間的人，如果沒有任何機制保證， A 進入房間之后，還

沒有出來； B 是不是也可以進入房間，打斷 A 在房間里的隱私，這個就是不具備原子性的，

那我們應該如何解決這個問題呢？是不是只要給房間加一把鎖， A 進去就把門鎖上，其他人是不是就進不來了，這樣

就保證了這段代碼的原子性了，

有時也把這個現象叫做同步互斥，表示操作是互相排斥的，

不保證原子性，如果一個執行緒正在對一個變數操作，中途其他執行緒插入進來了，如果這個操作被打斷了，結果就可能是錯誤的，

1.2.2 代碼“優化”

一段代碼是這樣的：

1. 去前臺取下 U 盤

2. 去教室寫 10 分鐘作業

3. 去前臺取下快遞

如果是在單執行緒情況下， JVM 、 CPU 指令集會對其進行優化，比如，按 1->3->2 的方式執行，也是沒問題，可以少跑一次前臺，這種叫做指令重排序，

剛才那個例子中，單執行緒情況是沒問題的，優化是正確的，但在多執行緒場景下就有問題了，什么問題呢，可能快遞是在你寫作業的10 分鐘內被另一個執行緒放過來的，或者被人變過了，如果指令重排序了，代碼就會是錯誤的，

二：如何解決執行緒不安全的問題

2.1 通過synchronized關鍵字

synchronized 的底層是使用作業系統的 mutex lock 實作的，

當執行緒釋放鎖時， JMM 會把該執行緒對應的作業記憶體中的共享變數重繪到主記憶體中

當執行緒獲取鎖時， JMM 會把該執行緒對應的本地記憶體置為無效，從而使得被監視器保護的臨界區代碼必須從主內存中讀取共享變數

synchronized 用的鎖是存在 Java物件頭里的， synchronized 同步快對同一條執行緒來說是可重入的，不會出現自己把自己鎖死的問題；同步塊在已進入的執行緒執行完之前，會阻塞后面其他執行緒的進入，

鎖的 SynchronizedDemo 物件

public class SynchronizedDemo {

public synchronized static void methond() {

}

public static void main(String[] args) {

method();

// 進入方法會鎖 SynchronizedDemo.class 指向物件中的鎖；出方法會釋放

SynchronizedDemo.class 指向的物件中的鎖

}

}

鎖的 SynchronizedDemo 類的物件

public class SynchronizedDemo {

public synchronized static void methond() {

}

public static void main(String[] args) {

method();

// 進入方法會鎖 SynchronizedDemo.class 指向物件中的鎖；出方法會釋放

SynchronizedDemo.class 指向的物件中的鎖

}

}

明確鎖的物件

public class SynchronizedDemo {

public void methond() {

// 進入代碼塊會鎖 this 指向物件中的鎖；出代碼塊會釋放 this 指向的物件中的鎖

synchronized (this) {

}

}

public static void main(String[] args) {

SynchronizedDemo demo = new SynchronizedDemo();

demo.method();

}

}

public class SynchronizedDemo {

public void methond() {

// 進入代碼塊會鎖 SynchronizedDemo.class 指向物件中的鎖；出代碼塊會釋放

SynchronizedDemo.class 指向的物件中的鎖

synchronized (SynchronizedDemo.class) {

}

}

public static void main(String[] args) {

SynchronizedDemo demo = new SynchronizedDemo();

demo.method();

}

}

2.2 volatile

這里提一下volatile：

首先，被volatile關鍵字修飾的變數，編譯器與運行時都會注意到這個變數是共享的，因此不會將該變數上的操作與其他記憶體操作一起重排序，volatile變數不會被快取在暫存器或者對其他處理器不可見的地方，因此在讀取volatile型別的變數時總會回傳最新寫入的值，

在訪問volatile變數時不會執行加鎖操作，因此也就不會使執行執行緒阻塞，因此volatile變數是一種比sychronized關鍵字更輕量級的同步機制，當對非 volatile 變數進行讀寫的時候，每個執行緒先從記憶體拷貝變數到CPU快取中，如果計算機有多個CPU，每個執行緒可能在不同的CPU上被處理，這意味著每個執行緒可以拷貝到不同的 CPU cache 中，而宣告變數是 volatile 的，JVM 保證了每次讀變數都從記憶體中讀，跳過 CPU cache 這一步

三：wait和notify關鍵字

3.1 wait方法

其實 wait() 方法就是使執行緒停止運行，

1. 方法 wait() 的作用是使當前執行代碼的執行緒進行等待， wait() 方法是 Object 類的方法，該方法是用來將當前執行緒

置入 “ 預執行佇列 ” 中，并且在 wait() 所在的代碼處停止執行，直到接到通知或被中斷為止，

2. wait() 方法只能在同步方法中或同步塊中呼叫，如果呼叫 wait() 時，沒有持有適當的鎖，會拋出例外，

3. wait() 方法執行后，當前執行緒釋放鎖，執行緒與其它執行緒競爭重新獲取鎖，

public static void main(String[] args) throws InterruptedException {

Object object = new Object();

synchronized (object) {

System.out.println(" 等待中 ...");

object.wait();

System.out.println(" 等待已過 ...");

}

System.out.println("main 方法結束 ...");

}

這樣在執行到 object.wait() 之后就一直等待下去，那么程式肯定不能一直這么等待下去了，這個時候就需要使用到了

另外一個方法喚醒的方法 notify() ，

3.2 notify方法

notify 方法就是使停止的執行緒繼續運行，

1. 方法 notify() 也要在同步方法或同步塊中呼叫，該方法是用來通知那些可能等待該物件的物件鎖的其它執行緒，對

其發出通知 notify ，并使它們重新獲取該物件的物件鎖，如果有多個執行緒等待，則有執行緒規劃器隨機挑選出一個

呈 wait 狀態的執行緒，

2. 在 notify() 方法后，當前執行緒不會馬上釋放該物件鎖，要等到執行 notify() 方法的執行緒將程式執行完，也就是退出

同步代碼塊之后才會釋放物件鎖，

class MyThread implements Runnable {
    private boolean flag;
    private Object obj;
    public MyThread(boolean flag, Object obj) {
        super();
        this.flag = flag;
        this.obj = obj;
    }
    public void waitMethod() {
        synchronized (obj) {
            try {
                while (true) {
                    System.out.println("wait()方法開始.. " +
                            Thread.currentThread().getName());
                    obj.wait();
                    System.out.println("wait()方法結束.. " +
                            Thread.currentThread().getName());
                    return;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    public void notifyMethod() {
        synchronized (obj) {
            try {
                System.out.println("notifyAll()方法開始.. " +
                        Thread.currentThread().getName());
                obj.notifyAll();
                System.out.println("notifyAll()方法結束.. " +
                        Thread.currentThread().getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    @Override
    public void run() {
        if (flag) {
            this.waitMethod();
        } else {
            this.notifyMethod();
        }
    }
}
public class TestThread {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        MyThread waitThread1 = new MyThread(true, object);
        MyThread waitThread2 = new MyThread(true, object);
        MyThread waitThread3 = new MyThread(true, object);
        MyThread notifyThread = new MyThread(false, object);
        Thread thread1 = new Thread(waitThread1, "wait執行緒A");
        Thread thread2 = new Thread(waitThread2, "wait執行緒B");
        Thread thread3 = new Thread(waitThread3, "wait執行緒C");
        Thread thread4 = new Thread(notifyThread, "notify執行緒");
        thread1.start();
        thread2.start();
        thread3.start();
        Thread.sleep(1000);
        thread4.start();
        System.out.println("main方法結束!!");
    }
}

從結果上來看第一個執行緒執行的是一個 waitMethod 方法，該方法里面有個死回圈并且使用了 wait 方法進入等待狀態

將釋放鎖，如果這個執行緒不被喚醒的話將會一直等待下去，這個時候第二個執行緒執行的是 notifyMethod 方法，該方

法里面執行了一個喚醒執行緒的操作，并且一直將 notify 的同步代碼塊執行完畢之后才會釋放鎖然后繼續執行 wait 結束

列印陳述句，

注意： wait ， notify 必須使用在 synchronized 同步方法或者代碼塊內，

3.3 wait和sleep對比（面試常考）

其實理論上 wait 和 sleep 完全是沒有可比性的，因為一個是用于執行緒之間的通信的，一個是讓執行緒阻塞一段時間，

唯一的相同點就是都可以讓執行緒放棄執行一段時間，用生活中的例子說的話就是婚禮時會吃糖，和家里自己吃糖之間

有差別，說白了放棄執行緒執行只是 wait 的一小段現象，

當然為了面試的目的，我們還是總結下：

1. wait 之前需要請求鎖，而 wait 執行時會先釋放鎖，等被喚醒時再重新請求鎖，這個鎖是 wait 對像上的 monitor

lock

2. sleep 是無視鎖的存在的，即之前請求的鎖不會釋放，沒有鎖也不會請求，

3. wait 是 Object 的方法

4. sleep 是 Thread 的靜態方法

四：多執行緒案例

4.1 餓漢模式單執行緒

class Singleton {

private static Singleton instance = new Singleton();

private Singleton() {}

public static Singleton getInstance() {

return instance;

}

4.2 懶漢模式單執行緒

class Singleton {

private static Singleton instance = null;

private Singleton() {}

public static Singleton getInstance() {

if (instance == null) {

instance = new Singleton();

}

return instance;

}

}

4.3 懶漢模式多執行緒低性能版

class Singleton {

private static Singleton instance = null;

private Singleton() {}

public synchronized static Singleton getInstance() {

if (instance == null) {

instance = new Singleton();

}

return instance;

}

}

4.4懶漢模式-多執行緒版-二次判斷-性能高

class Singleton {

private static volatile Singleton instance = null;

private Singleton() {}

public static Singleton getInstance() {

if (instance == null) {

synchronized (Singleton.class) {

if (instance == null) {

instance = new Singleton();

}

}

}

return instance;

}

}

總結

多執行緒的部分暫時分享到這里，但其實還有很多沒有沒有涉及，等日后深刻理解后再來分享，碼文不易，多謝大家支持，感激不盡！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/308740.html

標籤：java

上一篇：Java中的資料型別

下一篇：初識Java以及一些常見的資料型別

兩步幫你搞定多執行緒之最后一步

緒論

一：執行緒安全問題

1.1 提出問題

1.2 不安全的原因

1.2.1 原子性

1.2.2 代碼“優化”

二：如何解決執行緒不安全的問題

2.1 通過synchronized關鍵字

2.2 volatile

三：wait和notify關鍵字

3.1 wait方法

3.2 notify方法

3.3 wait和sleep對比（面試常考）

四：多執行緒案例

4.1 餓漢模式單執行緒

4.2 懶漢模式單執行緒

4.3 懶漢模式多執行緒低性能版

4.4懶漢模式-多執行緒版-二次判斷-性能高

總結