通常，我們可以將線程定義為一個(gè)子進(jìn)程，它具有最小的進(jìn)程單元，是輕量級(jí)的，并且具有獨(dú)立的執(zhí)行路徑。這些線程使用共享內(nèi)存，但它們獨(dú)立運(yùn)行，因此即使線程中存在異常也不會(huì)影響其他線程的工作，盡管它們共享相同的內(nèi)存。

正如我們?cè)谏蠄D中所觀察到的，一個(gè)線程在進(jìn)程內(nèi)部運(yùn)行，線程之間將進(jìn)行基于上下文的切換，操作系統(tǒng)中可以運(yùn)行多個(gè)進(jìn)程，每個(gè)進(jìn)程又可以同時(shí)運(yùn)行多個(gè)線程。多線程概念廣泛應(yīng)用于游戲、動(dòng)畫等領(lǐng)域。

多任務(wù)處理的概念

為了幫助用戶操作系統(tǒng)為用戶提供了多任務(wù)處理的特權(quán)，用戶可以在機(jī)器上同時(shí)執(zhí)行多個(gè)操作?？梢酝ㄟ^(guò)兩種方式啟用此多任務(wù)處理：

基于進(jìn)程的多任務(wù)處理

基于線程的多任務(wù)處理

1. 基于進(jìn)程的多任務(wù)處理(Multiprocessing)

在這種類型的多任務(wù)處理中，進(jìn)程是重量級(jí)的，每個(gè)進(jìn)程都分配了一個(gè)單獨(dú)的內(nèi)存區(qū)域。并且由于進(jìn)程是重量級(jí)的，進(jìn)程之間的通信成本很高，進(jìn)程之間的切換需要很長(zhǎng)時(shí)間，因?yàn)樗婕凹虞d、保存到寄存器、更新映射、列表等操作。

2. 基于線程的多任務(wù)處理

正如我們上面所討論的，線程具有輕量級(jí)的特性，共享相同的地址空間，線程之間的通信成本也很低。

為什么使用線程?

現(xiàn)在，我們可以理解為什么要使用線程，因?yàn)樗鼈兙哂休p量級(jí)的優(yōu)勢(shì)，并且可以以低成本提供多個(gè)線程之間的通信，從而有助于在共享內(nèi)存環(huán)境中進(jìn)行有效的多任務(wù)處理。

線程的生命周期

線程在其生命周期中會(huì)進(jìn)入不同的狀態(tài)，讓我們通過(guò)以下幾行了解這些狀態(tài)：在其生命周期中，線程會(huì)經(jīng)歷以下狀態(tài)，即：

新州

活動(dòng)狀態(tài)

等待/阻塞狀態(tài)

定時(shí)等待狀態(tài)

終止?fàn)顟B(tài)

我們可以在上圖中看到線程中不同狀態(tài)的工作，讓我們?cè)敿?xì)了解每個(gè)狀態(tài)：

(1)新狀態(tài)

默認(rèn)情況下，一個(gè)Thread會(huì)處于一個(gè)new狀態(tài)，在這個(gè)狀態(tài)下，代碼還沒(méi)有運(yùn)行，執(zhí)行過(guò)程還沒(méi)有啟動(dòng)。

(2)活躍狀態(tài)

默認(rèn)情況下，處于新狀態(tài)的 Thread 在調(diào)用 start() 方法時(shí)會(huì)轉(zhuǎn)移到 Active 狀態(tài)，他的 Active 狀態(tài)包含兩個(gè)子狀態(tài)，即：

可運(yùn)行狀態(tài)：在此狀態(tài)下，線程已準(zhǔn)備好在任何給定時(shí)間運(yùn)行，線程調(diào)度程序的工作是為可運(yùn)行狀態(tài)保留的線程提供線程時(shí)間。已獲得多線程的程序共享在線程之間共享的時(shí)間間隔切片，因此，這些線程運(yùn)行一段較短的時(shí)間跨度，并在可運(yùn)行狀態(tài)下等待獲取它們的時(shí)間間隔調(diào)度切片。

Running State：當(dāng)Thread接收到Thread Scheduler分配的CPU時(shí)，從“Runnable”狀態(tài)轉(zhuǎn)為“Running”狀態(tài)。在其給定時(shí)間片會(huì)話期滿后，它再次回到“可運(yùn)行”狀態(tài)并等待下一個(gè)時(shí)間片。

(3)等待/阻塞狀態(tài)

如果線程處于非活動(dòng)狀態(tài)但處于臨時(shí)狀態(tài)，則它處于等待或阻塞狀態(tài)，例如，如果有兩個(gè)線程 T1 和 T2，其中 T1 需要與攝像頭通信，而其他線程 T2 已經(jīng)使用攝像頭進(jìn)行通信掃描然后T1等待直到T2線程完成它的工作，在這個(gè)狀態(tài)下T1停在等待狀態(tài)，在另一種情況下，用戶調(diào)用了兩個(gè)具有相同功能的線程T2和T3，并且都具有線程調(diào)度程序給定的相同時(shí)間片那么線程 T1、T2 都處于阻塞狀態(tài)。當(dāng)有多個(gè)線程停在阻塞/等待狀態(tài)時(shí)，線程調(diào)度程序通過(guò)拒絕不需要的線程并按優(yōu)先級(jí)分配 CPU 來(lái)清除隊(duì)列。

(4)定時(shí)等待狀態(tài)

有時(shí)等待線程的較長(zhǎng)持續(xù)時(shí)間會(huì)導(dǎo)致饑餓，如果我們舉個(gè)例子，比如有兩個(gè)線程 T1，T2 等待 CPU，并且 T1 正在進(jìn)行關(guān)鍵編碼操作，如果它在執(zhí)行操作之前不退出 CPU，那么 T2 將是暴露在不確定的情況下等待更長(zhǎng)時(shí)間，為了避免這種饑餓情況，我們有 Timed Waiting 等待狀態(tài)以避免這種情況，因?yàn)樵?Timed Waiting 中，每個(gè)線程都有一個(gè)調(diào)用 sleep() 方法的時(shí)間段，并且在時(shí)間到期，線程開始執(zhí)行其任務(wù)。

(5)終止?fàn)顟B(tài)

由于以下原因，線程將處于終止?fàn)顟B(tài)：

正常情況下，線程在完成其任務(wù)時(shí)會(huì)終止。

有時(shí)，線程可能會(huì)由于異常事件(如分段錯(cuò)誤、異常等)而終止。這種終止可以稱為異常終止。

終止的線程意味著它已經(jīng)死了并且不再可用。

什么是主線程?

正如我們所熟悉的，我們?cè)诿總€(gè) Java 程序中創(chuàng)建 Main 方法，它作為代碼由 JVM 執(zhí)行的入口點(diǎn)，同樣在這個(gè)多線程概念中，每個(gè)程序都有一個(gè)主線程，默認(rèn)情況下由JVM，因此無(wú)論何時(shí)在 Java 中創(chuàng)建程序，JVM 都會(huì)為其執(zhí)行提供主線程。

如何使用 Java 編程語(yǔ)言創(chuàng)建線程?

我們可以使用兩種方式在 java 中創(chuàng)建線程，即：

通過(guò)擴(kuò)展線程類

通過(guò)實(shí)現(xiàn) Runnable 接口

通過(guò)擴(kuò)展Thread類

我們可以使用 Thread 類在 Java 中運(yùn)行線程，Thread 類提供構(gòu)造函數(shù)和方法來(lái)創(chuàng)建線程并在線程上執(zhí)行操作，線程擴(kuò)展了可以實(shí)現(xiàn) Runnable 接口的 Thread 類。我們使用以下構(gòu)造函數(shù)來(lái)創(chuàng)建線程：

線

線程(可運(yùn)行 r)

線程(字符串名稱)

Thread(Runnable r, String name)

通過(guò)擴(kuò)展線程類創(chuàng)建線程的示例代碼：

import java.io.*;
import java.util.*;
public class GFG extends Thread {
	// initiated run method for Thread
	public void run()
	{
		System.out.println("Thread Started Running...");
	}
	public static void main(String[] args)
	{
		GFG g1 = new GFG();
		// invoking Thread
		g1.run();
	}
}

輸出

線程開始運(yùn)行...

使用 Runnable 接口創(chuàng)建線程的示例代碼：

import java.io.*;
import java.util.*;
public class GFG implements Runnable {
	// method to start Thread
	public void run()
	{
		System.out.println(
			"Thread is Running Successfully");
	}
	public static void main(String[] args)
	{
		GFG g1 = new GFG();
		// initializing Thread Object
		Thread t1 = new Thread(g1);
		t1.run();
	}
}

輸出

線程運(yùn)行成功

使用 Thread(String name) 在 Java 中創(chuàng)建線程的示例代碼：

import java.io.*;
import java.util.*;
public class GFG {
	public static void main(String args[])
	{
		// Thread object created
		// and initiated with data
		Thread t = new Thread("Hello!");
		// Thread gets started
		t.start();
		// getting data of
		// Thread through String
		String s = t.getName();
		System.out.println(s);
	}
}

輸出

你好！

使用 Thread(Runnable r, String name) 創(chuàng)建線程對(duì)象的示例 Java 代碼：

import java.io.*;
import java.util.*;
public class GFG implements Runnable {
	public void run()
	{
		System.out.println(
			"Thread is created and running successfully...");
	}
	public static void main(String[] args)
	{
		// aligning GFG Class with
		// Runnable interface
		Runnable r1 = new GFG();
		Thread t1 = new Thread(r1, "My Thread");
		// Thread object started
		t1.run();
		// getting the Thread
		// with String Method
		String str = t1.getName();
		System.out.println(str);
	}
}

輸出

線程已創(chuàng)建并成功運(yùn)行...
我的線程

探索不同線程狀態(tài)的 Java 程序：

讓我們通過(guò)在線程 t1 和 t2 上實(shí)現(xiàn)它們來(lái)了解線程狀態(tài)的工作原理。

輸出：

import java.io.*;
import java.util.*;
class GFG implements Runnable {
	public void run()
	{
		// implementing try-catch Block to set sleep state
		// for inactive thread
		try {
			Thread.sleep(102);
		}
		catch (InterruptedException i1) {
			i1.printStackTrace();
		}
		System.out.println(
			"The state for t1 after it invoked join method() on thread t2"
			+ " " + ThreadState.t1.getState());
		// implementing try-catch block
		try {
			Thread.sleep(202);
		}
		catch (InterruptedException i2) {
			i2.printStackTrace();
		}
	}
}
// creation of ThreadState class
// to implement Runnable interface
public class ThreadState implements Runnable {
	public static Thread t1;
	public static ThreadState o1;
	public static void main(String args[])
	{
		o1 = new ThreadState();
		t1 = new Thread(o1);
		System.out.println("post-spanning, state of t1 is"
						+ " " + t1.getState());
		// lets invoke start() method on t1
		t1.start();
		// Now,Thread t1 is moved to runnable state
		System.out.println(
			"post invoking of start() method, state of t1 is"
			+ " " + t1.getState());
	}
	public void run()
	{
		GFG g1 = new GFG();
		Thread t2 = new Thread(g1);
		// Thread is created and its in new state.
		t2.start();
		// Now t2 is moved to runnable state
		System.out.println(
			"state of t2 Thread, post-calling of start() method is"
			+ " " + t2.getState());
		// create a try-catch block to set t1 in waiting
		// state
		try {
			Thread.sleep(202);
		}
		catch (InterruptedException i2) {
			i2.printStackTrace();
		}
		System.out.println(
			"State of Thread t2 after invoking to method sleep() is"
			+ " " + t2.getState());
		try {
			t2.join();
			System.out.println(
				"State of Thread t2 after join() is"
				+ " " + t2.getState());
		}
		catch (InterruptedException i3) {
			i3.printStackTrace();
		}
		System.out.println(
			"state of Thread t1 after completing the execution is"
			+ " " + t1.getState());
	}
}

輸出

后跨越，t1 的狀態(tài)是新的
調(diào)用 start() 方法后，t1 的狀態(tài)為 RUNNABLE
t2 線程的狀態(tài)，調(diào)用 start() 方法后為 RUNNABLE
t1 在線程 t2 上調(diào)用 join method() 后的狀態(tài) TIMED_WAITING
調(diào)用方法 sleep() 后線程 t2 的狀態(tài)為 TIMED_WAITING
join() 終止后線程 t2 的狀態(tài)
執(zhí)行完成后線程 t1 的狀態(tài)為 RUNNABLE

以上就是關(guān)于“Java線程詳解”的介紹，大家如果想了解更多相關(guān)知識(shí)，不妨來(lái)關(guān)注一下本站的Java在線學(xué)習(xí)，里面的課程內(nèi)容細(xì)致全面，很適合沒(méi)有基礎(chǔ)的小伙伴學(xué)習(xí)，希望對(duì)大家能夠有所幫助。