1.線程是什么

（shift + F6）改類名

1.1.并發(fā)編程是什么

（1）當前的CPU，都是多核心CPU

（2）需要一些特定的編程技巧，把要完成的仍無，拆解成多個部分，并且分別讓他們在不同的cpu上運行。

? ? ? ?要不然就會編程，一核有難，多核圍觀的場景

? ? ? 并發(fā)編程指的是（并行+并發(fā)）

（3）通過多進程編程的模式就可以達到并發(fā)編程的效果。??

? ? ? ?因為進程可以被調(diào)度到不同的cpu上面運行

? ? ? 此時就可以把多個cpu核心核心都很好的利用起來

?(4)雖然多進程編程可以解決上述問題，但是帶來了新的問題。

1.2.問題？

（1）在編程過程中，服務(wù)器開發(fā)的圈子李，這種并發(fā)編程要能夠給多個客戶端提供服務(wù)。

如果同一時間來了很多客戶端，服務(wù)器如果只利用一個cpu核心工作，速度會比較慢

（2）多搞幾個廚師，來炒菜，這樣就大幅的提高了效率

（3）一個比較好的做法就是每個客戶端連上服務(wù)器，服務(wù)器都創(chuàng)建一個新的進程，給客戶端提供服務(wù)，這個客戶端斷開了，服務(wù)器再把進程示范掉

如果服務(wù)器，頻繁有客戶端來來去去，服務(wù)器就需要頻繁創(chuàng)建銷毀進程。（服務(wù)器響應(yīng)速度會變慢）

1.3.如何解決這個問題？線程的引出

引入線程，主要的出現(xiàn)，就是為了解決上述進程，太重量的問題

（1）線程（thread）也叫做輕量級進程（創(chuàng)建銷毀的開銷更小）。

（2）線程可以理解為進程的一部分，一個進程中可以包含一個線程或者多個線程

（3）描述進程使用的是PCB這樣的結(jié)構(gòu)體，事實上更嚴格的說，一個PCB其實是描述一個進程的，若干個PCB聯(lián)合在一起，是描述一個進程的。

（4）pcb中包括（pid 內(nèi)存指針 文件描述表 狀態(tài)上下文，優(yōu)先級，記賬信息 tgid）每一個線程所提供的pid是不一樣的但是tgit是一樣的，所以我們可以用tgit來判斷這個線程是不是在一個線程下面

（5）還要同一個進程的若干個線程，這里的內(nèi)存指針和文件描述表，其實是同一個。?

（6）狀態(tài)上下文優(yōu)先級記賬信息每個線程有一組自己的屬性

（7）同一個進程中的若干個線程之間，是相同的內(nèi)存資源和文件資源的。

? ? ? ? ? 線程之間可以互相訪問

進程是系統(tǒng)資源分配的基本單位

線程是系統(tǒng)調(diào)度執(zhí)行的基本單位

同一個進程包括N個線程，線程之間是共用資源

只有你創(chuàng)建第一個線程的時候，去進行資源的申請操作，后序再創(chuàng)建線程，都沒有申請資源的過程了。

1.3.1并發(fā)編程

（1）在我們引入了進程以后，那么我們就可以思考，進程的作用是什么？

（2）圖解舉例

?（3）我們現(xiàn)在的計算機不都是好多核心，所以我們可以用多個線程來對工作進行拆分

（4）由于成本很高，而且電腦的核心也并不是特別的多，所以我們引出了多線程編程。

? ? ? ? ?相當于線程為進程分擔了問題

（5）這時候就有同學(xué)提出問題，是不是線程越多越好，這當然不是，因為線程的調(diào)度也是需要分配資源的，合適的線程可以幫助你來更好的管理資源，但是如果線程過多的化那么線程就會變慢。

（6）其中我們還要思考一個問題就是線程的調(diào)度資源到底花費到哪里

（7）其中多核CPU才能進行這種操作

?（8）其中，在線程不是太多的情況下，也可能發(fā)生線程安全的問題。

1.4總結(jié)

總結(jié)：為啥說線程更加輕量，開銷更小，核心就在于，創(chuàng)建進程可能包含多個線程，這個過程中，涉及到資源分配，資源釋放。

1.5線程于進程的關(guān)系以及相關(guān)問題

1.6關(guān)鍵面試題（線程和進程的區(qū)
別）

2.代碼實現(xiàn)線程和進程、

線程本身是操作系統(tǒng)提供的。

操作系統(tǒng)提供了API讓我們操作系統(tǒng)

JVM就對操作系統(tǒng)的api進行封裝

線程這里提供了thread類實現(xiàn)了封裝

2.1線程的代碼實現(xiàn)

其中，操作系統(tǒng)提供了api來對線程進行操作，然而我們的編譯器，使用了JVM（java虛擬機）來進行操作，操作系統(tǒng)的api，其中，在java中我們使用的就是Thread類來對線程進行操作

2.1.1Thread 代碼的基本實現(xiàn)

其中，run方法是Thread中本來就有的方法?,我們把他重寫了

進入源代碼

可以看到我們重寫了run方法。

2.1.1.1注意事項

（1）上面的這段代碼其實是創(chuàng)建了兩個線程，分別是main線程，另一個就是t線程

（2）其中main是主線程，也就是jvm在運行的時候就會創(chuàng)建出來。

（3）其中一個線程中至少包含一個進程，然后再進程中，至少包含一個線程，在沒有引入多并發(fā)編程之前，我們運行的程序都是一個進程，然后我們在一個線程下面編寫代碼。

（4）在上面的程序中就是，一個進程，然后進程的下面有兩個線程，分別是t線程，然后是jvm生成的主線程mian

2.1.2線程的狀況（線程一直進行來進行分析）

其中try catch來對其進行捕獲，是因為防止在其他線程或者什么東東調(diào)用正在休眠的線程，這時候就會一直等下去，也就是阻塞，所以我們要用trycatch來進行處理

try {// 嘗試執(zhí)行這里的代碼，可能會拋出異常
} catch (ExceptionType1 e) {// 如果try塊中的代碼拋出了ExceptionType1類型的異常，則執(zhí)行這里的代碼
} catch (ExceptionType2 e) {// 如果try塊中的代碼拋出了ExceptionType2類型的異常，則執(zhí)行這里的代碼
} finally {// 無論是否發(fā)生異常，finally塊中的代碼總是會被執(zhí)行
}

代碼整體實現(xiàn)

package thread;
class MyThread extends Thread{public void run(){while(true){System.out.println("HelloThread1");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}
public class Demo1 {public static void main(String[] args) {Thread t = new MyThread();t.start();while(true){System.out.println("HelloThread1");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

?其中main和t線程是并發(fā)執(zhí)行的

其中我們要注意的一點就是sleep后面的休眠時間的單位是ms，其中sleep的作用就是將這個停一下在方到系統(tǒng)上面的CPU上面進行執(zhí)行

時間到了以后就會解除阻塞狀態(tài)也就是。

它可以讓我們的CPU的調(diào)度有休息可以更好的處理資源的調(diào)度

2.1.3線程的使用情況（2.1.2中的代碼）

在運行的時候我們可以看到每秒鐘打印一次

其中main可能t線程的前面

t線程也可能在main線程的后面

也就是誰搶上資源誰就進行輸出

2.1.4其他一些關(guān)系線程的東西就一起來說明了

（1）

?總的來說就是，我們定義了一個線程的基本框架（MyThread類），其中在main方法中的Thread t = new MyThread只是實例化這個對象而已，也沒有創(chuàng)建線程，這時候的start是Thread中里面的方法，只有在調(diào)用這個方法的時候，才會使用我們實例化的線程框架，來創(chuàng)建線程

通俗點說就是

（2）其中要注意的是

?所以剛才寫的代碼就是線程的串行執(zhí)行

?2.2Thread的五種寫法

2.2.1第一種創(chuàng)建一個類繼承Thread方法

這個是我們一開始說的那個方法

2.2.2第二種創(chuàng)建一個類描述線程，實現(xiàn)Thread的方法?

這個方法實現(xiàn)線程的方式是比較好的方式

它能大大的降低耦合度

我們不同于第一種創(chuàng)建，我們是實例化Thread然后把MyRunnable作為參數(shù)傳入實例化的對象中作為參數(shù)

兩種Thread的對比（1）和（2）種方法

2.2.3第三種創(chuàng)建?使用匿名內(nèi)部類創(chuàng)建線程框架（繼承Thread類）

代碼實現(xiàn)

這個定義了一個匿名內(nèi)部類來對,這個匿名內(nèi)部類直接繼承Thread類然后重寫Thread的中的run方法，然后最后t.star就可以了

總結(jié)

?2.2.4第四種創(chuàng)建方式lambod表達式創(chuàng)建（JDK8的新屬性）

這個方式可以理解為用函數(shù)式接口的方法

在Thread類中式?jīng)]有抽象方法的，但是在Thread中實現(xiàn)了Runnable接口，里面有一個run抽象方法，lambod表達式就會重寫這個方法來做出線程的框架

相較于Thread的內(nèi)部類來實現(xiàn)來說 lambad表達式只能用函數(shù)式接口來重寫run，但是比內(nèi)部類實現(xiàn)來說方便許多，匿名內(nèi)部類實現(xiàn)的化比它麻煩一點，但是它的擴展性比lamda表達式要好很多

注意的一點就是主線程一直在其他線程完成以后再執(zhí)行的

代碼實現(xiàn)

2.2.5第五種方法是實現(xiàn)Runnable重寫run使用內(nèi)部類

總結(jié)

?

?2.3線程的幾種其他用法

2.3.1給線程定義名字

（1）在線程的結(jié)尾來定義名字

代碼示例

package thread;public class Demo6{public static void main(String[] args) {Thread t = new Thread(()->{while (true){System.out.println("make name from Thread");try {Thread.sleep(10000);} catch (InterruptedException e) {e.printStackTrace();}}},"Frank");t.start();}
}

?2.4Catch中寫的是什么？Sleep的注意事項

（1）

?（2）

其中我們要注意的就是在main方法中我們有兩種方法來處理sleep

分別時 ：try catch?和Throws

用try catch 可以捕獲異常然后程序員選則如何處理這個異常

用Throws是捕獲的異常必須要優(yōu)先處理

2.5小結(jié)

3線程的區(qū)別?

線程分為分為前臺線程和后臺線程

前臺線程就是這個線程不結(jié)束java程序

后臺線程就是這前臺線程結(jié)束那么他就結(jié)束了

4將進程設(shè)置為后臺進程

代碼實現(xiàn)

public class DaemonThreadExample {public static void main(String[] args) {// 創(chuàng)建一個線程Thread daemonThread = new Thread(new Runnable() {@Overridepublic void run() {while (true) {try {System.out.println("Daemon Thread is running...");Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}});// 將線程設(shè)置為后臺線程daemonThread.setDaemon(true);// 啟動線程daemonThread.start();// 主線程執(zhí)行完畢，由于daemonThread是后臺線程，程序不會等待它執(zhí)行完畢就會退出System.out.println("Main thread is exiting...");}
}

5.其他知識的擴充

（1）

6.如何讓線程中斷?

我們可以定義一個布爾值的變量其中，我們可以用布爾值來控制循環(huán)的開始和結(jié)束。

代碼實現(xiàn)

其中要注意的是外部類成員是不會報錯

（2）線程的中斷

總結(jié)一下，`t`線程在`sleep`狀態(tài)時，就像你的朋友決定去睡覺并且不想被打擾一樣，它是不會響應(yīng)中斷請求的。如果你想讓它在需要的時候提前醒來，你需要在編寫代碼時，讓它能夠檢查并響應(yīng)中斷請求。

6.1線程如何更好的中斷

代碼解析

首先，我們要明白什么是線程中斷。在Java中，線程中斷是一種協(xié)作機制，允許一個線程請求另一個線程停止它正在做的事情。這通常是因為某種原因，比如用戶取消了操作，或者系統(tǒng)需要釋放資源。

Thread.currentThread().isInterrupted()
這個方法用來檢查當前線程是否已經(jīng)被其他線程中斷。中斷狀態(tài)是一個標志，當一個線程調(diào)用另一個線程的
interrupt()
方法時，它會設(shè)置這個標志。

while (!Thread.currentThread().isInterrupted())
這個循環(huán)的意思是：“只要當前線程還沒有被中斷，就繼續(xù)執(zhí)行循環(huán)里的代碼。” 如果線程在循環(huán)內(nèi)部被中斷（比如其他線程調(diào)用了它的
interrupt()
方法），那么
isInterrupted()
方法會返回
true
，循環(huán)條件變?yōu)?br /> false
，循環(huán)就會停止。

現(xiàn)在，讓我們看一個簡單的例子：

假設(shè)你正在煮一壺水，并且你想在水開之前不斷檢查它。你可以把煮水的過程想象成一個線程的任務(wù)。如果突然有急事要離開，你可能會想中斷這個線程（也就是停止檢查水是否開了）。

在這個例子中，
while (!Thread.currentThread().isInterrupted())
就像是你在不斷地問自己：“我是不是應(yīng)該停止檢查水是否開了？” 只要你沒有被中斷（也就是沒有急事發(fā)生），你就會繼續(xù)檢查。一旦你收到中斷信號（比如有人叫你），你就會停止檢查并去處理其他事情。

Thread.interrupt()
方法就像是有人按下了停止按鈕，告訴線程：“你應(yīng)該停止你正在做的事情了。” 而
isInterrupted()
方法就像是線程在回答：“好的，我已經(jīng)收到停止的信號了。”

這時候當我們進行運行的時候會發(fā)現(xiàn)雖然我們返回了true想要中斷，但是卻沒有中斷，這是因為sleep會將false再修改回true，這是為了能夠讓程序員更好的控制線程而不是讓程序自己控制線程，我們可以再catch中選擇他是繼續(xù)往下進行還是結(jié)束

圖解

7線程的其他方法

?詳細圖解

其要注意的就是前臺線程結(jié)束后臺線程不管如何都會結(jié)束，而后臺線程結(jié)束那么前臺線程是不會結(jié)束的。

注意事項

3.Thread中的join方法（線程的阻塞）

3.1join方法的本質(zhì)

（1）

圖解

（2）join方法的本質(zhì)是指的是使用了這個方法的線程就會阻塞

圖解

所以main線程永遠是最后進行執(zhí)行的。

其中要注意的就是如果沒有設(shè)置sleep就是哪個線程先用join那么哪個線程就先執(zhí)行，還有就是只有start了以后才能join，如果休眠時間一樣也按這種方式處理，如果休眠時間不一樣，那么休眠間短的線程先執(zhí)行然后再是休眠時間最長的，最后再是main線程。

3.2代碼示例

public class JoinExample {public static void main(String[] args) {Thread thread1 = new Thread(() -> {System.out.println("Thread 1 starting...");try {Thread.sleep(1000); // 模擬耗時操作} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Thread 1 ending...");});Thread thread2 = new Thread(() -> {System.out.println("Thread 2 starting...");try {Thread.sleep(1500); // 模擬耗時操作，比線程1稍微長一些} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Thread 2 ending...");});thread1.start(); // 啟動線程1thread2.start(); // 啟動線程2try {thread1.join(); // 等待線程1完成thread2.join(); // 等待線程2完成} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Main thread continuing..."); // 當兩個子線程都完成后，主線程繼續(xù)執(zhí)行}
}

3.3join最大等待時間

1. 概念 join方法可以理解為誰調(diào)用這個方法誰就會被阻塞然后等待這個線程運行結(jié)束以后然后恢復(fù)執(zhí)行。

2.這個就相當于join等待不能一直等待，我們可以規(guī)定一個時間來限制他。

圖示(深度解析)

3.4sleep 和join 方法的區(qū)別

（1）sleep在java的庫中是native方法也就是本地方法，它的底層我們是看不到的

（2）通俗點來講，sleep是控制這個線程的休眠時間而不是兩個代碼的執(zhí)行的間隔時間。

（3）sleep是根據(jù)時間戳來對其進行休眠時間的判定

（3）system.currentTimeMillis（）這個代碼可以獲得我們系統(tǒng)的時間戳

注意事項

（4）對于join方法來說，這個就是真正的阻塞，只有前面沒有調(diào)用這個方法的線程執(zhí)行結(jié)束，這個阻塞才會恢復(fù)然后執(zhí)行這個調(diào)用這個join方法的線程?

4.引出線程安全問題（為下一篇文章做基礎(chǔ)）

4.1引言

（1）我們之前提到過線程的狀態(tài)，其中我們也可以叫它為PCB狀態(tài)，其中l(wèi)inux 和windos系統(tǒng)，linux系統(tǒng)有非常成熟的系統(tǒng)來操控PCB，當然windos系統(tǒng)中也會有選項來對其進行操作，只不過性能方面沒有比linux更好罷了。

（2）其中在我們java的jdk中的jvm虛擬機中，nb的大佬程序員都為我們封裝好了這些東西來對其進行操作，相較于C++來說，java方便太多，C++語言的特征是性能高穩(wěn)定但是編寫難度較高。

4.2 六種PCB狀態(tài)梳理

（1）NEW狀態(tài)

這個狀態(tài)就是Thread線程的對象已經(jīng)有了，沒有進行start，系統(tǒng)內(nèi)部的線程還沒有創(chuàng)建。

（2）.Terminated狀態(tài)

這個狀態(tài)是Thread線程的對象有了，也執(zhí)行完畢，然后被銷毀，最后還剩下一個Thread對象。

（3）Runnable狀態(tài)（就緒狀態(tài)）

這個指的是，這個線程已經(jīng)調(diào)度到了系統(tǒng)的CPU上面，其中有兩種情況。

第一種就是：這個線程已經(jīng)在CPU上面，但是還沒有執(zhí)行

第二種就是：這個線程已經(jīng)在CPU上面進行執(zhí)行了

！！！！！！我看了很多資料講解的都不是很好，他們將這兩種狀態(tài)分開了，叫出了兩種名稱，我認為其實沒啥用，因為都已經(jīng)到CPU上面了，已經(jīng)不是人能決定的了，而是全部由系統(tǒng)決定，你就算再nb你能對系統(tǒng)進行操作嗎？？所以這兩種狀態(tài)我都稱之為就緒狀態(tài)。

5.阻塞的三種狀態(tài)講解

最后一個狀態(tài)我們在下一篇文章中進行講解

打開idea的文件夾找到查看線程狀態(tài)的軟件，來對阻塞進行講解

可以看到，join是死等，join帶有最大阻塞時間和sleep休眠是TIMD-WAITING是帶有時間的阻塞。

這個的作用就是在你以后工作的時候來判斷你的各個線程的狀態(tài)來更好的開發(fā)項目

（1）線程不安全示例

相當于它會重復(fù)的對數(shù)據(jù)進行讀取這是非常不好的。

我們可以進行串行執(zhí)行

這樣就好了

所以死鎖問題就是這樣產(chǎn)生的。

（1）為什么，發(fā)生這種問題的簡單原因。

?（2）其中在上面的加到5000的情況下面還有一個情況就是兩個加在一起小于5w的情況。

在多線程環(huán)境中，每個線程都有自己的 CPU 緩存和工作內(nèi)存。當一個線程修改了變量的值時，這個變化不會立即反映到主內(nèi)存中，而是在適當?shù)臅r機才會同步到主內(nèi)存中。其他線程在讀取這個變量的值時，可能會直接從自己的 CPU 緩存或者工作內(nèi)存中讀取，而不是從主內(nèi)存中讀取，這就導(dǎo)致了可能讀取到舊值的情況發(fā)生。