02.關於線程你必須知道的8個問題（上）

来源:https://www.cnblogs.com/wyz1994/archive/2022/12/24/17001688.html
-Advertisement-
Play Games

大家好，我是王有志，歡迎來到《Java面試都問啥？》的第一篇技術文章。 這個系列會從Java部分開始，接著是MySQL和Redis的內容，同時會繼續更新數據結構與演算法的部分，這樣在第一階段，我們就完成了面試“三幻神”的挑戰。 Java的部分從併發編程開始，接著是Java虛擬機，最後是集合框架。至於J ...


大家好，我是王有志，歡迎來到《Java面試都問啥？》的第一篇技術文章。

這個系列會從Java部分開始，接著是MySQL和Redis的內容，同時會繼續更新數據結構與演算法的部分，這樣在第一階段，我們就完成了面試“三幻神”的挑戰。

Java的部分從併發編程開始，接著是Java虛擬機，最後是集合框架。至於Java基礎，因為大部分只是API的使用，所以只提供整理好的題目，而涉及到反射，動態代理等內容，會在集合框架完成後補充。

那麼話不多說，我們直接開始吧。

併發編程都問啥？

每個模塊開始時，我都會放出這一模塊中知識點的統計數據，供大家參考。

統計中，我將併發編程分為了5個知識點：

  • 線程基礎：線程的基本概念，Thread類的使用等；
  • 線程池：線程池的原理，線程池的使用等；
  • synchronized：原理，鎖升級，優化等；
  • volatile：原理，指令重排，JMM相關等；
  • ThreadLocal：原理，使用方法，記憶體泄漏等；
  • JUC：Lock介面，併發容器，CAS，AQS等。

統計到併發編程關鍵詞174次，線程出現37次，線程池出現22次，synchronized出現30次，volatile出現12次，ThreadLocal出現8次，JUC出現44次，剩餘21次僅提到多線程/併發編程。

從圖中看，ThreadLocal和volatile出現概率較低，但個人建議面試準備中，併發編程的部分要全量準備。

數據大家都看到了，接下來看看各大公司都會問哪些關於線程的問題。這部分題目主要收集自某準網面經，淺紫色底色的題目是我和小伙伴在面試過程遇到過的。

MarkDown的表格實在太醜了，偷個懶使用圖片代替了，文末附上整理後Excel的獲取方式。

關於線程你必須知道的8個問題

涉及到概念性的題目就不過多贅述了，這些可以通過百度百科獲取到答案。在這裡我挑選了8道比較有代表性的問題，和大家分享我的理解。

併發編程的3要素

併發編程的3要素：

  • 原子性：操作不可分割，要麼不間斷的全部執行，要麼全部不執行；
  • 有序性：指程式按照代碼的順序結構執行；
  • 可見性：當一個線程修改了共用變數後，其它線程也是立即可見的。

概念很簡單，我們寫一些代碼展示下有序性和可見性的問題（原子性實在沒有想到很好的例子，有沒有小伙伴提供示例呢）。

有序性問題

public static class Singleton {
	private Singleton instance;
	public Singleton getInstance() {
	    if (instance == null) {
	        instance = new Singleton();
	    }
	    return instance;
	}
  
	private Singleton() {
	}
}

這是有序性問題的經典案例--未做同步控制的單例模式。當instance還未初始化時，多個線程同時調用getInstance方法，很容易出現其中一個線程獲取到的instance為NULL。

這裡涉及Java創建對象的操作，CPU時間片分配的問題，解決它的辦法也有很多，暫時按下不表，放到volatile關鍵字的內容中詳細解釋。

可見性問題

private static boolean flag = true;

public static void main(String[] args) throws InterruptedException {
    new Thread(() -> {
        while (flag) {
        }
        System.out.println("線程：" + Thread.currentThread().getName() + "，flag：" + flag);
    }, "block_thread").start();

    TimeUnit.MICROSECONDS.sleep(500);
    
    new Thread(() -> {
        flag = false;
        System.out.println("線程：" + Thread.currentThread().getName() + "，flag：" + flag);
    }, "change_thread").start();
}

很明顯，在change_thread中修改了flag，並不會使block_thread得到解脫，這就是共用變數線上程間不可見的問題。

Java創建線程的方式

通常網上的資料會給出4種創建線程的方式：

  • 繼承Thread類
  • 實現Runnable介面
  • 實現Callable介面
  • 通過線程池創建

先不評價這個答案的正確性，我們先來看看繼承Thread類，實現Runnable介面和實現Callable介面是如何使用的。

繼承Thread類

public class ByThread {
	public static void main(String[] args) throws InterruptedException {
	    System.out.println("main的線程：" + Thread.currentThread().getName());
	    MyThread myThread = new MyThread();
	    myThread.start();
	}
	
	static class MyThread extends Thread {
	    @Override
	    public void run() {
	        System.out.println("MyThread的線程：" + Thread.currentThread().getName());
	    }
	}
}

繼承Thread類要實現run方法，用於完成業務邏輯，該方法來自於Runnable介面。啟動線程通過Thread.start方法，方法內通過調用native方法start0來啟動線程。

實現Runnable介面

public class ByRunnable {
    public static void main(String[] args) {
        System.out.println("main的線程：" + Thread.currentThread().getName());
        new Thread(new MyRunnable()).start();
    }

    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("MyRunnable的線程：" + Thread.currentThread().getName());  
        }
    }
}

實現Runnable介面同樣要實現run方法，啟動線程依舊是通過Thread.start方法。

實質上繼承Thread類和實現Runnable介面沒有差別，只不過是隔代實現run方法還是直接實現run方法。

實現Callable介面

public class ByCallable  {  
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main的線程：" + Thread.currentThread().getName());
        Callable<String> callable = new MyCallable();
        FutureTask <String> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();
        System.out.println("MyCallable的執行線程：" + futureTask.get());
    }
    
    static class MyCallable implements Callable<String> {
        @Override
        public String call() {
            System.out.println("MyCallable的線程：" + Thread.currentThread().getName());
            return Thread.currentThread().getName();
        }
    }
}

實現Callable介面看起來會複雜一些，但通過代碼可以看出來，最終還是回歸到Thread.start方法，根據經驗，這種方式是不是和Runnable有關係？

另外，我們註意到這種方式中藉助到了FutureTask類，來看看FutureTask的繼承關係：

不出所料，FutureTask同樣要實現Runnable.run方法，只不過這次由FutureTask實現，FutureTask在run方法中調用Callable.call方法來執行業務邏輯。

我們來回顧下這3種方式的特點，啟動線程都是通過Thread.start方法，start方法的基本執行單位是Runnable介面，它們直接的差異在於如何實現Runnable.run方法。另一個差異就是Callable.call方法是有返回值的，而Runnable.run方法沒有返回值。

使用線程池

public class ByThreadPool {
    public static void main(String[] args) {
        System.out.println("main的線程：" + Thread.currentThread().getName());
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("線程池的線程：" + Thread.currentThread().getName());
            }
        };
        executorService.execute(runnable);
        executorService.shutdown();
    }
}

使用線程池依舊離不開Runnable.run方法，會不會和Callable一樣本質上還是Thread.start？

如果不熟悉ThreadPoolExecutor源碼的話，可以採用斷點的方式去跟蹤源碼，重點關註ThreadPoolExecutor.execute和ThreadPoolExecutor.addWorker兩個方法。

我們可以在addWorker方法中發現兩行關鍵代碼：

final Thread t = w.thread;
t.start();

這證實了關於ThreadPoolExecutor底層調用的猜想，最終依舊是通過Thread.start方法啟動。

回到最初的問題，Java有幾種創建線程的方式？

如果從Java的層面來看，可以認為創建Thread類的實例對象就完成了線程的創建，而調用Thread.start0可以認為是操作系統層面的線程創建和啟動。

至於網上說的4種創建線程的方式，個人認為將它們歸類到線程中業務邏輯的實現方式更合理。

Java的線程狀態

Java中定義了6種線程狀態（與OS的線程狀態有差別），線程狀態的枚舉類被定義為Thread的內部類State。

public enum State {
	NEW,
	RUNNABLE,
	BLOCKED,
	WAITING,
	TIMED_WAITING,
	TERMINATED;
}

需要註意，Java中並未定義線程的RUNNING狀態，而是通過RUNNABLE包含了RUNNABLE（可運行）和RUNNING（運行中）。

建議大家閱讀源碼中的註釋，很清晰的解釋了每個狀態的場景。下麵我還是通過幾段代碼展示線程的不同狀態。

Tips：代碼中出現的TimeUnit.MILLISECONDS.sleep是為了確保線程已經進入期望的狀態，如果不能很好的理解，文末附有Gitee地址，工程中的代碼有註釋。

常規狀態的轉換

這裡指的是線程從創建後（NEW），到啟動後（RUNNABLE），再到最後終止（TERMINATED）的一種無競爭的線程狀態轉換。

  • NEW（新建）：創建線程後尚未啟動（未調用start方法）；
  • RUNNABLE（可運行）：可運行狀態的線程在Java虛擬機中等待調度線程選中獲取CPU時間片；
  • TERMINATED（終止）：線程執行結束。

寫一段簡單的代碼來看下：

public class NormalStateTransition {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println("線程[" + thread.getName() + "]創建，狀態：[" + thread.getState() + "]");
        thread.start();
        System.out.println("線程[" + thread.getName() + "]啟動，狀態：[" + thread.getState() + "]");
        TimeUnit.SECONDS.sleep(2);
        System.out.println("線程[" + thread.getName() + "]結束，狀態：[" + thread.getState() + "]");
    }
}

代碼非常簡單，這裡就不再解釋了。

常規狀態的轉換：

阻塞狀態的轉換

阻塞狀態是一種“異常”的狀態，通常是在等待資源。

BLOCKED（阻塞）：等待監視器鎖而阻塞的線程狀態，處於阻塞狀態的線程正在等待監視器鎖進入同步的代碼塊/方法，或者在調用Object.wait之後重新進入同步的代碼塊/方法。

再寫一段代碼：

public class BlockedStateTransition {
    public static void main(String[] args) throws InterruptedException {
        AtomicBoolean locker = new AtomicBoolean(false);
        new Thread(() -> {
            synchronized (locker) {
                try {
                    TimeUnit.MILLISECONDS.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
  
        Thread t = new Thread(() -> {
            synchronized (locker) {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("線程[" + Thread.currentThread().getName() + "]阻塞後，狀態：[" + Thread.currentThread().getState() + "]");
            }
        });
        System.out.println("線程[" + t.getName() + "]創建，狀態：[" + t.getState() + "]");
        t.start();
        System.out.println("線程[" + t.getName() + "]啟動，狀態：[" + t.getState() + "]");
        System.out.println("線程[" + t.getName() + "]阻塞中，狀態：[" + t.getState() + "]");
        TimeUnit.MILLISECONDS.sleep(5000);
        System.out.println("線程[" + t.getName() + "]結束，狀態：[" + t.getState() + "]");
    }
}

首先是匿名線程持有locker，接著線程t啟動，進入RUNNABLE狀態，線程t嘗試獲取locker，進入BLOCKED狀態，等待後獲取到locker，進入RUNNABLE狀態，最後執行結束，進入TERMINATED狀態。

阻塞狀態轉換：

等待狀態的轉換

關於等待狀態，Java源碼的註釋有詳細描述如何進入等待狀態，以及如何喚醒處於等待狀態的線程：

Thread state for a waiting thread. A thread is in the waiting state due to calling one of the following methods:
Object.wait with no timeout
Thread.join with no timeout
LockSupport.park
A thread in the waiting state is waiting for another thread to perform a particular action. For example, a thread that has called Object.wait() on an object is waiting for another thread to call Object.notify() or Object.notifyAll() on that object. A thread that has called Thread.join() is waiting for a specified thread to terminate.

WAITING（等待）：線程處於等待狀態，處於等待狀態的線程正在等待另一個線程執行的特定操作（通知或中斷）。

再再寫一段代碼：

public class WaitingStateTransition {
    public static void main(String[] args) throws InterruptedException {
        AtomicBoolean locker = new AtomicBoolean(false);
        Thread t = new Thread(() -> {
            synchronized (locker) {
                try {
                    TimeUnit.MILLISECONDS.sleep(100);
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("線程[" + Thread.currentThread().getName() + "]喚醒，狀態：[" + Thread.currentThread().getState() + "]");
            }
        });
        System.out.println("線程[" + t.getName() + "]創建，狀態：[" + t.getState() + "]");
        t.start();
        System.out.println("線程[" + t.getName() + "]啟動，狀態：[" + t.getState() + "]");
        TimeUnit.MILLISECONDS.sleep(150);
        System.out.println("線程[" + t.getName() + "]等待，狀態：[" + t.getState() + "]");
  
        new Thread(() -> {
            synchronized (locker) {
                locker.notify();
            }
        }).start();
        TimeUnit.MILLISECONDS.sleep(100);
        System.out.println("線程[" + t.getName() + "]結束，狀態：[" + t.getState() + "]");
    }
}

線程t創建後，進入NEW狀態，啟動後，進入RUNNABLE狀態，locker.wait後，進入WAITING狀態，匿名線程啟動，locker.notify後，喚醒線程t，進入RUNNABLE狀態，最後線程執行結束，進入TERMINATED狀態。

等待狀態的轉換：

限時等待狀態的轉換

Java源碼的註釋上，也很詳細的解釋瞭如何進入限時等待：

Thread state for a waiting thread with a specified waiting time. A thread is in the timed waiting state due to calling one of the following methods with a specified positive waiting time:
Thread.sleep
Object.wait with timeout
Thread.join with timeout
LockSupport.parkNanos
LockSupport.parkUntil

TIMED_WAITING（限時等待）：線程處於限時等待狀態，與等待狀態不同的是，在指定時間後，線程會被自動喚醒。

Tips：也有翻譯成超時等待的，但是我覺得不太合適。

再再再寫一段代碼：

public class TimedWaitingStateTransition {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("線程[" + Thread.currentThread().getName() + "]限時等待後，狀態：[" + Thread.currentThread().getState() + "]");
        });
        System.out.println("線程[" + t.getName() + "]創建，狀態：[" + t.getState() + "]");  
        t.start();
        System.out.println("線程[" + t.getName() + "]啟動，狀態：[" + t.getState() + "]");  
        TimeUnit.MILLISECONDS.sleep(50);
        System.out.println("線程[" + t.getName() + "]限時等待中，狀態：[" + t.getState() + "]");
        TimeUnit.MILLISECONDS.sleep(100);
        System.out.println("線程[" + t.getName() + "]結束，狀態：[" + t.getState() + "]");  
    }
}

線程t創建後，進入NEW狀態，啟動後進入RUNNABLE狀態，線程休眠100ms，進入TIMED_WAITING狀態，休眠時間結束後，進入RUNNABLE狀態，最後線程執行結束，進入TERMINATED狀態。

限時等待狀態的轉換：

線程狀態轉換總結

上面我們通過4段代碼瞭解了線程狀態的轉換，下麵我們通過一張圖來總結下線程的狀態轉換。

結語

今天分享了併發編程的統計數據，因此面試題目較少，不過還是希望對你有幫助。

下一篇內容是剩餘的5個知識點（如果一篇能夠寫完的話）：

  • Thread類核心方法
  • 同步與互斥
  • Java線程調度方式
  • 死鎖的產生與解決
  • 多線程的優點

本篇文章的代碼倉庫：

關註王有志，回覆面試題合集獲取整理後的面試題（正在同步更新，可以持續關註）。

好了，今天就到這裡了，Bye~~


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • #Python #OpenCV 使用Python為你的聖誕節增添更多樂趣
    ​ 目錄 1.前言 2.目標與效果展示 3.下載OpenCV圖形識別庫 4.下載python支持的v2模塊 5.圖片素材 6.代碼 1.前言 ​ 編輯 Merry Christmas！今天是2022年12月24日，今晚是平安夜在這裡提前祝大家聖誕節快樂！ 大家可能對@官方微信給自己的頭像加上一頂聖誕 ...
  • 還在手動發早安嗎？教你用java實現每日給女友微信發送早安
    摘要：教你如何用java實現每日給女友微信發送早安等微信信息。 本文分享自華為雲社區《java實現每日給女友微信發送早安等微信信息》，作者：穆雄雄 。 前言 據說這個功能最近在抖音上很火，我沒有抖音，沒有看到。 但是我在網上看了，相關案例確實很多，但是大家都是藉助於了微信服務號，在我看來，效果很不佳 ...
  • Spring IOC官方文檔學習筆記（四）之依賴項（下）
    一、選題的背景 （1）為什麼要選擇此選題？ 樂高是一個很受歡迎的玩具積木品牌，它們通常是成套出售的，用來製作特定的物品，每一套都包含許多不同形狀、大小和顏色的零件。它是一個有趣的數據集合，它包含了多年來集合的綜合列表，以及每個集合包含的部分數。提供了許多可供探索的空間，特別是因為“集合”文件包含了集 ...
  • C++基礎3
    C++ 基礎3 typedef 為現有類型創建一個新名字 主要有以下幾種形式: 為基本數據類型定義別名 為指針定義別名 為自定義數據類型定義別名 為數組定義別名 聲明函數 定義新名稱為了簡化一些複雜的數據類型,以方便使用 為基本數據類型定義名稱 語法typedef 舊類型 新名字 例如: typed ...
  • 紅袖添香,絕代妖嬈,Ruby語言基礎入門教程之Ruby3基礎數據類型(data types)EP02
    Ruby是強類型動態語言，即Ruby中一旦某一個對象被定義類型，如果不通過強制轉換操作，那麼它永遠就是該數據類型，並且只有在Ruby解釋器運行時才會檢測對象數據類型，它的一切皆為對象（包括 nil 值對象），可以通過調用內置class屬性來獲取該對象的具體數據類型。對於 Ruby 而言，所有類型都繼 ...
  • 每日演算法之數組中只出現一次的兩個數字
    JZ56 數組中只出現一次的兩個數字 題目 一個整型數組裡除了兩個數字只出現一次，其他的數字都出現了兩次。請寫程式找出這兩個只出現一次的數字 思路 演算法實現 既然有兩個數字只出現了一次，我們就統計每個數字的出現次數，利用哈希表的快速根據key值訪問其頻率值。 具體做法： step 1：遍曆數組，用哈 ...
  • VsCode搭建C語言運行環境以及終端亂碼問題解決
    在VsCode中搭建C/C++運行環境需要先安裝以下插件 1、安裝c/c++插件 2、安裝code runner插件 當然也可以安裝一些其他的美化插件根據個人習慣，但是以上這兩個是必裝的。 安裝好插件後來到插件主頁點擊卸載旁邊的小齒輪選擇擴展設置 找到擴展設置中的下圖選項並打上勾即可，設置完後重啟V ...
  • 國產paozhu c++ web framework 正式版發佈
    返回值類型後置語法，是為瞭解決函數返回值類型依賴於參數而導致難以確定返回值類型的問題。有了這種語法以後，對返回值類型的推導就可以用清晰的方式（直接通過參數做運算）描述出來，而不需要像 C++98/03 那樣使用晦澀難懂的寫法。 在泛型編程中，可能需要通過參數的運算來得到返回值的類型。比如如下的代碼： ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類