java多線程是什麼

① java多線程是什麼意思

Java多線程實現方式主要有三種：繼承Thread類、實現Runnable介面、使用ExecutorService、Callable、Future實現有返回結果的多線程。其中前兩種方式線程執行完後都沒有返回值，只有最後一種是帶返回值的。

1、繼承Thread類實現多線程
繼承Thread類的方法盡管被我列為一種多線程實現方式，但Thread本質上也是實現了Runnable介面的一個實例，它代表一個線程的實例，並且，啟動線程的唯一方法就是通過Thread類的start()實例方法。start()方法是一個native方法，它將啟動一個新線程，並執行run()方法。這種方式實現多線程很簡單，通過自己的類直接extend Thread，並復寫run()方法，就可以啟動新線程並執行自己定義的run()方法。例如：

代碼說明：
上述代碼中Executors類，提供了一系列工廠方法用於創先線程池，返回的線程池都實現了ExecutorService介面。
public static ExecutorService newFixedThreadPool(int nThreads)
創建固定數目線程的線程池。
public static ExecutorService newCachedThreadPool()
創建一個可緩存的線程池，調用execute 將重用以前構造的線程（如果線程可用）。如果現有線程沒有可用的，則創建一個新線程並添加到池中。終止並從緩存中移除那些已有 60 秒鍾未被使用的線程。
public static ExecutorService newSingleThreadExecutor()
創建一個單線程化的Executor。
public static ScheledExecutorService newScheledThreadPool(int corePoolSize)
創建一個支持定時及周期性的任務執行的線程池，多數情況下可用來替代Timer類。

總結：ExecutoreService提供了submit()方法，傳遞一個Callable，或Runnable，返回Future。如果Executor後台線程池還沒有完成Callable的計算，這調用返回Future對象的get()方法，會阻塞直到計算完成。

② java 面試 什麼是多線程

多線程是指一個應用程序同時執行多個任務，一般來說一個任務就是一個線程 ，而一個應用程序有一個以上的線程我們稱之為多線程。

補充內容

線程與進程的區別：

• 進程(程序)：是靜態概念，一個class文件、一個exe文件

• 線程：是一個程序裡面不同的執行路徑

舉例說明：

publicclassThreadTest{

	publicstaticvoidm1(){

		System.out.println("m1");
	}

	publicstaticvoidm2(){

		System.out.println("m2");
	}

	publicstaticvoidm3(){

		m1();
		m2();
	}

	publicstaticvoidmain(String[]args){

		m3();
	}}

程序中的路徑或者線程也就是main方法(共一條)：

③ java線程是什麼

一、操作系統中線程和進程的概念

現在的操作系統是多任務操作系統。多線程是實現多任務的一種方式。

進程是指一個內存中運行的應用程序，每個進程都有自己獨立的一塊內存空間，一個進程中可以啟動多個線程。比如在Windows系統中，一個運行的exe就是一個進程。

線程是指進程中的一個執行流程，一個進程中可以運行多個線程。比如java.exe進程中可以運行很多線程。線程總是屬於某個進程，進程中的多個線程共享進程的內存。

「同時」執行是人的感覺，在線程之間實際上輪換執行。

二、Java中的線程

在Java中，「線程」指兩件不同的事情：
1、java.lang.Thread類的一個實例；

2、線程的執行。

使用java.lang.Thread類或者java.lang.Runnable介面編寫代碼來定義、實例化和啟動新線程。

一個Thread類實例只是一個對象，像Java中的任何其他對象一樣，具有變數和方法，生死於堆上。

Java中，每個線程都有一個調用棧，即使不在程序中創建任何新的線程，線程也在後台運行著。

一個Java應用總是從main()方法開始運行，mian()方法運行在一個線程內，它被稱為主線程。

一旦創建一個新的線程，就產生一個新的調用棧。

線程總體分兩類：用戶線程和守候線程。

當所有用戶線程執行完畢的時候，JVM自動關閉。但是守候線程卻不獨立於JVM，守候線程一般是由操作系統或者用戶自己創建的

④ Java多線程程序設計詳細解析

一、理解多線程
多線程是這樣一種機制，它允許在程序中並發執行多個指令流，每個指令流都稱為一個線程，彼此間互相獨立。
線程又稱為輕量級進程，它和進程一樣擁有獨立的執行控制，由操作系統負責調度，區別在於線程沒有獨立的存儲空間，而是和所屬進程中的其它線程共享一個存儲空間，這使得線程間的通信遠較進程簡單。
多個線程的執行是並發的，也就是在邏輯上「同時」，而不管是否是物理上的「同時」。如果系統只有一個CPU，那麼真正的「同時」是不可能的，但是由於CPU的速度非常快，用戶感覺不到其中的區別，因此我們也不用關心它，只需要設想各個線程是同時執行即可。
多線程和傳統的單線程在程序設計上最大的區別在於，由於各個線程的控制流彼此獨立，使得各個線程之間的代碼是亂序執行的，由此帶來的線程調度，同步等問題，將在以後探討。
二、在Java中實現多線凱液慎程
我們不妨設想，為了創建一個新的線程，我們需要做些什麼？很顯然，我們必須指明這個線程所要執行的代碼，而這就是在Java中實現多線程我們所需要做的一切！
真是神奇！Java是如何做到這一點的？通過類！作為一個完全面向對象的語言，Java提供了類java.lang.Thread來方便多線程編程，這個類提供了大量的方法來方便我們控制自己的各個線程，我們以後的討論都將圍繞這個類進行。
那麼如何提供給 Java 我們要線程執行的代碼呢？讓我們來看一看 Thread 類。Thread 類最重要的方法是run()，它為Thread類的方法start()所調用，提供我們的線程所要執行的代碼。為了指定我們自己的代碼，只需要覆蓋它！
方法一：繼承 Thread 類，覆蓋方法 run()，我們在創建的 Thread 類的子類中重寫 run() ,加入線程所要執行的代碼即可。下面是一個例子：
public class MyThread extends Thread
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println
("創建線程 " + number);
}
public void run() {
while(true) {
System.out.println
("線程 " + number + ":計數 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0;
i 〈 5; i++) new MyThread(i+1).start();
}
}
這種方法簡單明了，符合大家的習慣，但是，它也有一個很大的缺點，那就是如果我們的類已經從一個類繼承（如小程序必須繼承自 Applet 類），則無法再繼承 Thread 類，這時如果我們又不想建立一個新的類，應該怎麼辦呢？
我們不妨來探索一種新的方法：我們不創建Thread類的子類，而是直接使用它，那麼我們只能將我們的方法作為參數傳遞給 Thread 類的實例，有點類似回調函數。但是 Java 沒有指針，我們只能傳遞一個包含這個方法的類的實例。
那麼如何限制這個類盯敬必須包含這一方法呢？當然是使用介面！（雖然抽象類也可滿足，但是需要繼承，而我們之所以要採用這種新方法，不就是為了避免繼承帶來的限制嗎？）
Java 提供了介面 java.lang.Runnable 來支持這種方法。
方法二：實現 Runnable 介面
Runnable介面只有一個方法run()，我們聲明自己的類實現Runnable介面並提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務。但是Runnable介面並沒有任何對線程的支持，我們還必須創建Thread類的實例，這一點通過Thread類的構造函數public Thread(Runnable target);來實現。下面埋禪是一個例子：
public class MyThread implements Runnable
{
int count= 1, number;
public MyThread(int num)
{
number = num;
System.out.println("創建線程 " + number);
}
public void run()
{
while(true)
{
System.out.println
("線程 " + number + ":計數 " + count);
if(++count== 6) return;
}
}
public static void main(String args[])
{
for(int i = 0; i 〈 5;
i++) new Thread(new MyThread(i+1)).start();
}
}
嚴格地說，創建Thread子類的實例也是可行的，但是必須注意的是，該子類必須沒有覆蓋 Thread 類的 run 方法，否則該線程執行的將是子類的 run 方法，而不是我們用以實現Runnable 介面的類的 run 方法，對此大家不妨試驗一下。
使用 Runnable 介面來實現多線程使得我們能夠在一個類中包容所有的代碼，有利於封裝，它的缺點在於，我們只能使用一套代碼，若想創建多個線程並使各個線程執行不同的代碼，則仍必須額外創建類，如果這樣的話，在大多數情況下也許還不如直接用多個類分別繼承 Thread 來得緊湊。
綜上所述，兩種方法各有千秋，大家可以靈活運用。
下面讓我們一起來研究一下多線程使用中的一些問題。
三、線程的四種狀態
1. 新狀態：線程已被創建但尚未執行（start() 尚未被調用）。
2. 可執行狀態：線程可以執行，雖然不一定正在執行。CPU 時間隨時可能被分配給該線程，從而使得它執行。
3. 死亡狀態：正常情況下 run() 返回使得線程死亡。調用 stop()或 destroy() 亦有同樣效果，但是不被推薦，前者會產生異常，後者是強制終止，不會釋放鎖。
4. 阻塞狀態：線程不會被分配 CPU 時間，無法執行。
四、線程的優先順序
線程的優先順序代表該線程的重要程度，當有多個線程同時處於可執行狀態並等待獲得 CPU 時間時，線程調度系統根據各個線程的優先順序來決定給誰分配 CPU 時間，優先順序高的線程有更大的機會獲得 CPU 時間，優先順序低的線程也不是沒有機會，只是機會要小一些罷了。
你可以調用 Thread 類的方法 getPriority() 和 setPriority()來存取線程的優先順序，線程的優先順序界於1(MIN_PRIORITY)和10(MAX_PRIORITY)之間，預設是5(NORM_PRIORITY)。
五、線程的同步
由於同一進程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴重的問題。Java語言提供了專門機制以解決這種沖突，有效避免了同一個數據對象被多個線程同時訪問。
由於我們可以通過 private 關鍵字來保證數據對象只能被方法訪問，所以我們只需針對方法提出一套機制，這套機制就是 synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。
1. synchronized 方法：通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如：
public synchronized void accessVal(int newVal);
synchronized 方法控制對類成員變數的訪問：每個類實例對應一把鎖，每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執行，否則所屬線程阻塞，方法一旦執行，就獨占該鎖，直到從該方法返回時才將鎖釋放，此後被阻塞的線程方能獲得該鎖，重新進入可執行狀態。
這種機制確保了同一時刻對於每一個類實例，其所有聲明為 synchronized 的成員函數中至多隻有一個處於可執行狀態（因為至多隻有一個能夠獲得該類實例對應的鎖），從而有效避免了類成員變數的訪問沖突（只要所有可能訪問類成員變數的方法均被聲明為 synchronized）。
在 Java 中，不光是類實例，每一個類也對應一把鎖，這樣我們也可將類的靜態成員函數聲明為 synchronized ，以控制其對類的靜態成員變數的訪問。
synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法 run() 聲明為 synchronized ，由於在線程的整個生命期內它一直在運行，因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以通過將訪問類成員變數的代碼放到專門的方法中，將其聲明為 synchronized ，並在主方法中調用來解決這一問題，但是 Java 為我們提供了更好的解決辦法，那就是 synchronized 塊。
2. synchronized 塊：通過 synchronized關鍵字來聲明synchronized 塊。語法如下：
synchronized(syncObject)
{
//允許訪問控制的代碼
}
#p#副標題#e#
synchronized 塊是這樣一個代碼塊，其中的代碼必須獲得對象 syncObject （如前所述，可以是類實例或類）的鎖方能執行，具體機制同前所述。由於可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。
六、線程的阻塞為了解決對共享存儲區的訪問沖突，Java 引入了同步機制，現在讓我們來考察多個線程對共享資源的訪問，顯然同步機制已經不夠了，因為在任意時刻所要求的資源不一定已經准備好了被訪問，反過來，同一時刻准備好了的資源也可能不止一個。為了解決這種情況下的訪問控制問題，Java 引入了對阻塞機制的支持。
阻塞指的是暫停一個線程的執行以等待某個條件發生（如某資源就緒），學過操作系統的同學對它一定已經很熟悉了。Java 提供了大量方法來支持阻塞，下面讓我們逐一分析。
1. sleep() 方法：sleep() 允許 指定以毫秒為單位的一段時間作為參數，它使得線程在指定的時間內進入阻塞狀態，不能得到CPU 時間，指定的時間一過，線程重新進入可執行狀態。典型地，sleep() 被用在等待某個資源就緒的情形：測試發現條件不滿足後，讓線程阻塞一段時間後重新測試，直到條件滿足為止。
2. suspend() 和 resume() 方法：兩個方法配套使用，suspend()使得線程進入阻塞狀態，並且不會自動恢復，必須其對應的resume() 被調用，才能使得線程重新進入可執行狀態。典型地，suspend() 和 resume() 被用在等待另一個線程產生的結果的情形：測試發現結果還沒有產生後，讓線程阻塞，另一個線程產生了結果後，調用 resume() 使其恢復。
3. yield() 方法：yield() 使得線程放棄當前分得的 CPU 時間，但是不使線程阻塞，即線程仍處於可執行狀態，隨時可能再次分得 CPU 時間。調用 yield() 的效果等價於調度程序認為該線程已執行了足夠的時間從而轉到另一個線程。
4. wait() 和 notify() 方法：兩個方法配套使用，wait() 使得線程進入阻塞狀態，它有兩種形式，一種允許 指定以毫秒為單位的一段時間作為參數，另一種沒有參數，前者當對應的 notify() 被調用或者超出指定時間時線程重新進入可執行狀態，後者則必須對應的 notify() 被調用。
初看起來它們與 suspend() 和 resume() 方法對沒有什麼分別，但是事實上它們是截然不同的。區別的核心在於，前面敘述的所有方法，阻塞時都不會釋放佔用的鎖（如果佔用了的話），而這一對方法則相反。
上述的核心區別導致了一系列的細節上的區別。
首先，前面敘述的所有方法都隸屬於 Thread 類，但是這一對卻直接隸屬於 Object 類，也就是說，所有對象都擁有這一對方法。初看起來這十分不可思議，但是實際上卻是很自然的，因為這一對方法阻塞時要釋放佔用的鎖，而鎖是任何對象都具有的，調用任意對象的 wait() 方法導致線程阻塞，並且該對象上的鎖被釋放。
而調用 任意對象的notify()方法則導致因調用該對象的 wait() 方法而阻塞的線程中隨機選擇的一個解除阻塞（但要等到獲得鎖後才真正可執行）。
其次，前面敘述的所有方法都可在任何位置調用，但是這一對方法卻必須在 synchronized 方法或塊中調用，理由也很簡單，只有在synchronized 方法或塊中當前線程才佔有鎖，才有鎖可以釋放。
同樣的道理，調用這一對方法的對象上的鎖必須為當前線程所擁有，這樣才有鎖可以釋放。因此，這一對方法調用必須放置在這樣的 synchronized 方法或塊中，該方法或塊的上鎖對象就是調用這一對方法的對象。若不滿足這一條件，則程序雖然仍能編譯，但在運行時會出現IllegalMonitorStateException 異常。
wait() 和 notify() 方法的上述特性決定了它們經常和synchronized 方法或塊一起使用，將它們和操作系統的進程間通信機製作一個比較就會發現它們的相似性：synchronized方法或塊提供了類似於操作系統原語的功能，它們的執行不會受到多線程機制的干擾，而這一對方法則相當於 block 和wakeup 原語（這一對方法均聲明為 synchronized）。
它們的結合使得我們可以實現操作系統上一系列精妙的進程間通信的演算法（如信號量演算法），並用於解決各種復雜的線程間通信問題。
關於 wait() 和 notify() 方法最後再說明兩點：
第一：調用 notify() 方法導致解除阻塞的線程是從因調用該對象的 wait() 方法而阻塞的線程中隨機選取的，我們無法預料哪一個線程將會被選擇，所以編程時要特別小心，避免因這種不確定性而產生問題。
第二：除了 notify()，還有一個方法 notifyAll() 也可起到類似作用，唯一的區別在於，調用 notifyAll() 方法將把因調用該對象的 wait() 方法而阻塞的所有線程一次性全部解除阻塞。當然，只有獲得鎖的那一個線程才能進入可執行狀態。
談到阻塞，就不能不談一談死鎖，略一分析就能發現，suspend() 方法和不指定超時期限的 wait() 方法的調用都可能產生死鎖。遺憾的是，Java 並不在語言級別上支持死鎖的避免，我們在編程中必須小心地避免死鎖。
以上我們對 Java 中實現線程阻塞的各種方法作了一番分析，我們重點分析了 wait() 和 notify()方法，因為它們的功能最強大，使用也最靈活，但是這也導致了它們的效率較低，較容易出錯。實際使用中我們應該靈活使用各種方法，以便更好地達到我們的目的。
七、守護線程
守護線程是一類特殊的線程，它和普通線程的區別在於它並不是應用程序的核心部分，當一個應用程序的所有非守護線程終止運行時，即使仍然有守護線程在運行，應用程序也將終止，反之，只要有一個非守護線程在運行，應用程序就不會終止。守護線程一般被用於在後台為其它線程提供服務。
可以通過調用方法 isDaemon() 來判斷一個線程是否是守護線程，也可以調用方法 setDaemon() 來將一個線程設為守護線程。
八、線程組
線程組是一個 Java 特有的概念，在 Java 中，線程組是類ThreadGroup 的對象，每個線程都隸屬於唯一一個線程組，這個線程組在線程創建時指定並在線程的整個生命期內都不能更改。
你可以通過調用包含 ThreadGroup 類型參數的 Thread 類構造函數來指定線程屬的線程組，若沒有指定，則線程預設地隸屬於名為 system 的系統線程組。
在 Java 中，除了預建的系統線程組外，所有線程組都必須顯式創建。在 Java 中，除系統線程組外的每個線程組又隸屬於另一個線程組，你可以在創建線程組時指定其所隸屬的線程組，若沒有指定，則預設地隸屬於系統線程組。這樣，所有線程組組成了一棵以系統線程組為根的樹。
Java 允許我們對一個線程組中的所有線程同時進行操作，比如我們可以通過調用線程組的相應方法來設置其中所有線程的優先順序，也可以啟動或阻塞其中的所有線程。
Java 的線程組機制的另一個重要作用是線程安全。線程組機制允許我們通過分組來區分有不同安全特性的線程，對不同組的線程進行不同的處理，還可以通過線程組的分層結構來支持不對等安全措施的採用。
Java 的 ThreadGroup 類提供了大量的方法來方便我們對線程組樹中的每一個線程組以及線程組中的每一個線程進行操作。
九、總結
在本文中，我們講述了 Java 多線程編程的方方面面，包括創建線程，以及對多個線程進行調度、管理。我們深刻認識到了多線程編程的復雜性，以及線程切換開銷帶來的多線程程序的低效性，這也促使我們認真地思考一個問題：我們是否需要多線程？何時需要多線程？
多線程的核心在於多個代碼塊並發執行，本質特點在於各代碼塊之間的代碼是亂序執行的。我們的程序是否需要多線程，就是要看這是否也是它的內在特點。
假如我們的程序根本不要求多個代碼塊並發執行，那自然不需要使用多線程；假如我們的程序雖然要求多個代碼塊並發執行，但是卻不要求亂序，則我們完全可以用一個循環來簡單高效地實現，也不需要使用多線程；只有當它完全符合多線程的特點時，多線程機制對線程間通信和線程管理的強大支持才能有用武之地，這時使用多線程才是值得的。
#p#副標題#e#

⑤ java 多線程

所要執行的指令，也包括了執行指令所需的系統資源，不同進程所佔用的系統資源相對獨立。所以進程是重量級的任務，它們之間的通信和轉換都需要操作系統付出較大的開銷。
線程是進程中的一個實體，是被系統獨立調度和分派的基本單位。線程自己基本上不擁有系統資源，但它可以與同屬一個進程的其他線程共享進程所擁有的全部資源。所以線程是輕量級的任務，它們之間的通信和轉換只需要較小的系統開銷。
Java支持多線程編程，因此用Java編寫的應用程序可以同時執行多個任務。Java的多線程機制使用起來非常方便，用戶只需關注程序細節的實現，而不用擔心後台的多任務系統。
Java語言里，線程表現為線程類。Thread線程類封裝了所有需要的線程操作控制。在設計程序時，必須很清晰地區分開線程對象和運行線程，可以將線程對象看作是運行線程的控制面板。在線程對象里有很多方法來控制一個線程是否運行，睡眠，掛起或停止。線程類是控制線程行為的唯一的手段。一旦一個Java程序啟動後，就已經有一個線程在運行。可通過調用Thread.currentThread方法來查看當前運行的是哪一個線程。

class ThreadTest{
public static void main(String args[]){
Thread t = Thread.currentThread();
t.setName("單線程"); //對線程取名為"單線程"
t.setPriority(8);
//設置線程優先順序為8，最高為10，最低為1，默認為5
System.out.println("The running thread: " + t);
// 顯示線程信息
try{
for(int i=0;i<3;i++){
System.out.println("Sleep time " + i);
Thread.sleep(100); // 睡眠100毫秒
}
}catch(InterruptedException e){// 捕獲異常
System.out.println("thread has wrong");
}
}
}

多線程的實現方法
繼承Thread類
可通過繼承Thread類並重寫其中的run()方法來定義線程體以實現線程的具體行為，然後創建該子類的對象以創建線程。
在繼承Thread類的子類ThreadSubclassName中重寫run()方法來定義線程體的一般格式為:
public class ThreadSubclassName extends Thread{
public ThreadSubclassName(){
..... // 編寫子類的構造方法，可預設
}
public void run(){
..... // 編寫自己的線程代碼
}
}
用定義的線程子類ThreadSubclassName創建線程對象的一般格式為:
ThreadSubclassName ThreadObject =
new ThreadSubclassName();
然後，就可啟動該線程對象表示的線程：
ThreadObject.start(); //啟動線程

應用繼承類Thread的方法實現多線程的程序。本程序創建了三個單獨的線程，它們分別列印自己的「Hello World!」。
class ThreadDemo extends Thread{
private String whoami;
private int delay;
public ThreadDemo(String s,int d){
whoami=s;
delay=d;
}
public void run(){
try{
sleep(delay);
}catch(InterruptedException e)
System.out.println("Hello World!" + whoami
+ " " + delay);
}
}
public class MultiThread{
public static void main(String args[]){
ThreadDemo t1,t2,t3;
t1 = new ThreadDemo("Thread1",
(int)(Math.random()*2000));
t2 = new ThreadDemo("Thread2",
(int)(Math.random()*2000));
t3 = new ThreadDemo("Thread3",
(int)(Math.random()*2000));
t1.start();
t2.start();
t3.start();
}
}

實現Runnable介面
編寫多線程程序的另一種的方法是實現Runnable介面。在一個類中實現Runnable介面(以後稱實現Runnable介面的類為Runnable類),並在該類中定義run()方法，然後用帶有Runnable參數的Thread類構造方法創建線程。
創建線程對象可用下面的兩個步驟來完成:
(1)生成Runnable類ClassName的對象
ClassName RunnableObject = new ClassName();
(2)用帶有Runnable參數的Thread類構造方法創建線程對象。新創建的線程的指針將指向Runnable類的實例。用該Runnable類的實例為線程提供 run()方法---線程體。
Thread ThreadObject = new Thread(RunnableObject);
然後，就可啟動線程對象ThreadObject表示的線程：
ThreadObject.start();
在Thread類中帶有Runnable介面的構造方法有:
public Thread(Runnable target);
public Thread(Runnable target, String name);
public Thread(String name);
public Thread(ThreadGroup group，Runnable target);
public Thread(ThreadGroup group，Runnable target，
String name);
其中，參數Runnable target表示該線程執行時運行target的run()方法，String name以指定名字構造線程，ThreadGroup group表示創建線程組。
用Runnable介面實現的多線程。
class TwoThread implements Runnable{
TwoThread(){
Thread t1 = Thread.currentThread();
t1.setName("第一主線程");
System.out.println("正在運行的線程: " + t1);
Thread t2 = new Thread(this,"第二線程");
System.out.println("創建第二線程");
t2.start();
try{
System.out.println("第一線程休眠");
Thread.sleep(3000);
}catch(InterruptedException e){
System.out.println("第一線程有錯");
}
System.out.println("第一線程退出");
}
public void run(){
try{
for(int i = 0;i < 5;i++){
System.out.println(「第二線程的休眠時間：」
+ i);
Thread.sleep(1000);
}
}catch(InterruptedException e){
System.out.println("線程有錯");
}
System.out.println("第二線程退出");
}
public static void main(String args[]){
new TwoThread();
}
}
程序運行結果如下：
正在運行的線程: Thread[第一主線程,5,main
創建第二線程
第一線程休眠
第二線程的休眠時間：0
第二線程的休眠時間：1
第二線程的休眠時間：2
第一線程退出
第二線程的休眠時間：3
第二線程的休眠時間：4
第二線程退出
另外,虛機團上產品團購,超級便宜

⑥ Java中，線程是什麼意思，多線程又是什麼

在計算機中當一個程序運行的時候就會創建至少一個進程，例如當我們運行QQ的時候，系統就會創建進程來處理我們平時的一些操作，當我們打開任務管理器的時候，在進程的列表裡面就可以找到QQ.exe的運行程序;

在計算機中處理進程之外還有另一個概念就是線程，線程是存在於進程當中，一個進程可以包含多個線程;當我們的計算機有多核處理器的時候，使用多線程可以加快程序的運算速率;如果一個進程中只有一個線程，當程序遇到一個比較耗時的計算的時候，由於程序是單線程的，那麼程序只能等待這個運算結束的時候再繼續運行，這樣會大大的降低程序的效率;當時用多個線程的時候，在某個線程遇到比較耗時的運算的時候，該線程可以繼續自己的運算，但是其他的線程也可以同步進行，這樣當耗時的計算結束之後，其他線程也將自己所需要的東西執行完畢，這樣就會很大的提高程序執行效率;

在程序運行中對於文件的保存相對於處理器的運算速度來說是很慢的，當我們程序中接收到一個保存文件的信息之後，我們可以創建一個保存文件的線程，在主線程中我們可以繼續進行我們的其他運算，這樣當文件保存好之後，我們的其他運算也會完成，互不影響;

在Java中我們可以創建一個自己的類繼承於Thread類，並且重寫run() 方法，當線程啟動之後，run()方法裡面的操作都在線程中進行處理，而不會影響主線程的信息;

當我們創建好一個自定義線程類之後，我們可以創建這個自定義線程的對象，進行線程的啟動;線程須調用start();方法進行啟動，這樣run()方法裡面的內容才會在線程中運行;如果我們不去調用start()方法，那我們只是創建了一個普通的類，即使我們手動調用run()方法，run()方法裡面的內容也不會在線程中運行;

在Java中線程主要有初始狀態，運行狀態，阻塞狀態，終止狀態等;當我們新創建一個線程對象的時候，此時線程的狀態為初始狀態;當我們調用start()之後，此時的線程才被激活成為運行狀態，之後run()方法裡面的信息才會在子線程中運行;我們可以在不同的階段調用不同的方法將線程設置為不同的狀態;比如有時候我們的操作需要等待其他線程中運算結束之後才可以繼續進行，這時候我們就可以將線程設置為等待狀態，當需要的資源滿足條件之後，可以繼續運行當前的線程;

以上的內容就是關於Java中線程是什麼，更多關於Java方面的問題可以看下這個視頻教程：網頁鏈接，希望我的回答能幫到你。

⑦ java中什麼叫做線程什麼叫多線程多線程的特點是什麼

1、在 Java 中，線程是一個獨立的執行路徑。換句者咐話說，一個線程是一個程序中的單獨的執行環境，首局純它可以並行地運行和其他線程。
2、多線程指的是在一個程序中，有多個線程在並行地運行。
3、多線程的一個特點是它們可以共享程序的臘兆資源，這樣可以更有效地利用程序的資源，例如處理器時間和內存。此外，多線程還可以使程序更響應，因為在一個線程中運行的任務可以在另一個線程中進行，而不會導致程序「假死」。

⑧ 什麼是Java多線程

多線程的概念？
說起多線程，那麼就不得不說什麼是線程，而說起線程，又不得不說什麼是進程。
進程（Process）是計算機中的程序關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操作系統結構的基礎。在早期面向進程設計的計算機結構中，進程是程序的基本執行實體；在當代面向線程設計的計算機結構中，進程是線程的容器。程序是指令、數據及其組織形式的描述，進程是程序的實體。
進程可以簡單的理解為一個可以獨立運行的程序單位。它是線程的集合，進程就是有一個或多個線程構成的，每一個線程都是進程中的一條執行路徑。
那麼多線程就很容易理解：多線程就是指一個進程中同時有多個執行路徑（線程）正在執行。
為什麼要使用多線程？
1.在一個程序中，有很多的操作是非常耗時的，如資料庫讀寫操作，IO操作等，如果使用單線程，那麼程序就必須等待這些操作執行完成之後才能執行其他操作。使用多線程，可以在將耗時任務放在後台繼續執行的同時，同時執行其他操作。
2.可以提高程序的效率。
3.在一些等待的任務上，如用戶輸入，文件讀取等，多線程就非常有用了。
缺點：
1.使用太多線程，是很耗系統資源，因為線程需要開辟內存。更多線程需要更多內存。
2.影響系統性能，因為操作系統需要在線程之間來回切換。
3.需要考慮線程操作對程序的影響，如線程掛起，中止等操作對程序的影響。
4.線程使用不當會發生很多問題。
總結：多線程是非同步的，但這不代表多線程真的是幾個線程是在同時進行，實際上是系統不斷地在各個線程之間來回的切換（因為系統切換的速度非常的快，所以給我們在同時運行的錯覺）。
2.多線程與高並發的聯系。
高並發：高並發指的是一種系統運行過程中遇到的一種「短時間內遇到大量操作請求」的情況，主要發生在web系統集中大量訪問或者socket埠集中性收到大量請求（例如：12306的搶票情況；天貓雙十一活動）。該情況的發生會導致系統在這段時間內執行大量操作，例如對資源的請求，資料庫的操作等。如果高並發處理不好，不僅僅降低了用戶的體驗度（請求響應時間過長），同時可能導致系統宕機，嚴重的甚至導致OOM異常，系統停止工作等。如果要想系統能夠適應高並發狀態，則需要從各個方面進行系統優化，包括，硬體、網路、系統架構、開發語言的選取、數據結構的運用、演算法優化、資料庫優化……。
而多線程只是在同/非同步角度上解決高並發問題的其中的一個方法手段，是在同一時刻利用計算機閑置資源的一種方式。
多線程在高並發問題中的作用就是充分利用計算機資源，使計算機的資源在每一時刻都能達到最大的利用率，不至於浪費計算機資源使其閑置。
3.線程的創建，停止，常用方法介紹。
1.線程的創建：
線程創建主要有2種方式，一種是繼承Thread類，重寫run方法即可；（Thread類實現了Runable介面）
另一種則是實現Runable介面，也需要重寫run方法。
線程的啟動，調用start（）方法即可。 我們也可以直接使用線程對象的run方法，不過直接使用，run方法就只是一個普通的方法了。

其他的還有： 通過匿名內部類的方法創建；實現Callable介面。。。。。

2.線程常用方法：
currentThread()方法：該方法返回當前線程的信息 .getName（）可以返回線程名稱。

isAlive()方法：該方法判斷當前線程是否處於活動狀態。
sleep()方法：該方法是讓「當前正在執行的線程「休眠指定的時間，正在執行的線程是指this.currentThread()返回的線程。
getId()方法：該方法是獲取線程的唯一標識。
3.線程的停止：
在java中，停止線程並不簡單，不想for。。break那樣說停就停，需要一定的技巧。

線程的停止有3種方法：
1.線程正常終止，即run()方法運行結束正常停止。
2.使用interrupt方法中斷線程。
3.使用stop方法暴力停止線程。
interrupt方法中斷線程介紹：
interrupt方法其實並不是直接中斷線程，只是給線程添加一個中斷標志。
判斷線程是否是停止狀態：
this.interrupted(); 判斷當前線程是否已經中斷。（判斷的是這個方法所在的代碼對應的線程，而不是調用對象對應的線程）

this.isInterrupted(); 判斷線程是否已經中斷。（誰調用，判斷誰）

註：.interrupted()與isInterrupted()的區別：
interrupted()方法判斷的是所在代碼對應的線程是否中斷，而後者判斷的是調用對象對應的線程是否停止
前者執行後有清除狀態的功能（如連續調用兩次時，第一次返回true，則第二次會返回false）
後者沒有清除狀態的功能（兩次返回都為true）
真正停止線程的方法：
異常法：
在run方法中 使用 this.interrupted();判斷線程終止狀態，如果為true則 throw new interruptedException()然後捕獲該異常即可停止線程。

return停止線程：
在run方法中 使用 this.interrupted();判斷線程終止狀態，如果為true則return停止線程。 （建議使用異常法停止線程，因為還可以在catch中使線程向上拋，讓線程停止的事件得以傳播）。

暴力法：
使用stop()方法強行停止線程（強烈不建議使用，會造成很多不可預估的後果，已經被標記為過時）
（使用stop方法會拋出 java.lang.ThreadDeath 異常，並且stop方法會釋放鎖，很容易造成數據不一致）
註：在休眠中停止線程：
在sleep狀態下停止線程 會報異常，並且會清除線程狀態值為false；
先停止後sleep，同樣會報異常 sleep interrupted；

4.守護線程。
希望對您有所幫助！~