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

正如我們在上圖中所觀察到的，一個線程在進程內部運行，線程之間將進行基于上下文的切換，操作系統中可以運行多個進程，每個進程又可以同時運行多個線程。多線程概念廣泛應用于游戲、動畫等領域。

多任務處理的概念

為了幫助用戶操作系統為用戶提供了多任務處理的特權，用戶可以在機器上同時執行多個操作。可以通過兩種方式啟用此多任務處理：

基于進程的多任務處理

基于線程的多任務處理

1. 基于進程的多任務處理(Multiprocessing)

在這種類型的多任務處理中，進程是重量級的，每個進程都分配了一個單獨的內存區域。并且由于進程是重量級的，進程之間的通信成本很高，進程之間的切換需要很長時間，因為它涉及加載、保存到寄存器、更新映射、列表等操作。

2. 基于線程的多任務處理

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

為什么使用線程?

現在，我們可以理解為什么要使用線程，因為它們具有輕量級的優勢，并且可以以低成本提供多個線程之間的通信，從而有助于在共享內存環境中進行有效的多任務處理。

線程的生命周期

線程在其生命周期中會進入不同的狀態，讓我們通過以下幾行了解這些狀態：在其生命周期中，線程會經歷以下狀態，即：

新州

活動狀態

等待/阻塞狀態

定時等待狀態

終止狀態

我們可以在上圖中看到線程中不同狀態的工作，讓我們詳細了解每個狀態：

(1)新狀態

默認情況下，一個Thread會處于一個new狀態，在這個狀態下，代碼還沒有運行，執行過程還沒有啟動。

(2)活躍狀態

默認情況下，處于新狀態的 Thread 在調用 start() 方法時會轉移到 Active 狀態，他的 Active 狀態包含兩個子狀態，即：

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

Running State：當Thread接收到Thread Scheduler分配的CPU時，從“Runnable”狀態轉為“Running”狀態。在其給定時間片會話期滿后，它再次回到“可運行”狀態并等待下一個時間片。

(3)等待/阻塞狀態

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

(4)定時等待狀態

有時等待線程的較長持續時間會導致饑餓，如果我們舉個例子，比如有兩個線程 T1，T2 等待 CPU，并且 T1 正在進行關鍵編碼操作，如果它在執行操作之前不退出 CPU，那么 T2 將是暴露在不確定的情況下等待更長時間，為了避免這種饑餓情況，我們有 Timed Waiting 等待狀態以避免這種情況，因為在 Timed Waiting 中，每個線程都有一個調用 sleep() 方法的時間段，并且在時間到期，線程開始執行其任務。

(5)終止狀態

由于以下原因，線程將處于終止狀態：

正常情況下，線程在完成其任務時會終止。

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

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

什么是主線程?

正如我們所熟悉的，我們在每個 Java 程序中創建 Main 方法，它作為代碼由 JVM 執行的入口點，同樣在這個多線程概念中，每個程序都有一個主線程，默認情況下由JVM，因此無論何時在 Java 中創建程序，JVM 都會為其執行提供主線程。

如何使用 Java 編程語言創建線程?

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

通過擴展線程類

通過實現 Runnable 接口

通過擴展Thread類

我們可以使用 Thread 類在 Java 中運行線程，Thread 類提供構造函數和方法來創建線程并在線程上執行操作，線程擴展了可以實現 Runnable 接口的 Thread 類。我們使用以下構造函數來創建線程：

線

線程(可運行 r)

線程(字符串名稱)

Thread(Runnable r, String name)

通過擴展線程類創建線程的示例代碼：

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();
	}
}

輸出

線程開始運行...

使用 Runnable 接口創建線程的示例代碼：

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();
	}
}

輸出

線程運行成功

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

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) 創建線程對象的示例 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);
	}
}

輸出

線程已創建并成功運行...
我的線程

探索不同線程狀態的 Java 程序：

讓我們通過在線程 t1 和 t2 上實現它們來了解線程狀態的工作原理。

輸出：

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 的狀態是新的
調用 start() 方法后，t1 的狀態為 RUNNABLE
t2 線程的狀態，調用 start() 方法后為 RUNNABLE
t1 在線程 t2 上調用 join method() 后的狀態 TIMED_WAITING
調用方法 sleep() 后線程 t2 的狀態為 TIMED_WAITING
join() 終止后線程 t2 的狀態
執行完成后線程 t1 的狀態為 RUNNABLE

以上就是關于“Java線程詳解”的介紹，大家如果想了解更多相關知識，不妨來關注一下本站的Java在線學習，里面的課程內容細致全面，很適合沒有基礎的小伙伴學習，希望對大家能夠有所幫助。