java執行線程

❶ java線程的作用什麼

線程同步我們可以在計算機上運行各種計算機軟體程序。每一個運行的程序可能包括多個獨立運行的線程（Thread）。 線程（Thread）是一份獨立運行的程序，有自己專用的運行棧。線程有可能和其他線程共享一些資源，比如，內存，文件，資料庫等。

當多個線程同時讀寫同一份共享資源的時候，可能會引起沖突。這時候，我們需要引入線程「同步」機制，即各位線程之間要有個先來後到，不能一窩蜂擠上去搶作一團。

同步這個詞是從英文synchronize（使同時發生）翻譯過來的。我也不明白為什麼要用這個很容易引起誤解的詞。既然大家都這么用，咱們也就只好這么將就。

線程同步的真實意思和字面意思恰好相反。線程同步的真實意思，其實是「排隊」：幾個線程之間要排隊，一個一個對共享資源進行操作，而不是同時進行操作。

因此，關於線程同步，需要牢牢記住的第一點是：線程同步就是線程排隊。同步就是排隊。線程同步的目的就是避免線程「同步」執行。這可真是個無聊的繞口令。

關於線程同步，需要牢牢記住的第二點是 「共享」這兩個字。只有共享資源的讀寫訪問才需要同步。如果不是共享資源，那麼就根本沒有同步的必要。

關於線程同步，需要牢牢記住的第三點是，只有「變數」才需要同步訪問。如果共享的資源是固定不變的，那麼就相當於「常量」，線程同時讀取常量也不需要同步。至少一個線程修改共享資源，這樣的情況下，線程之間就需要同步。

關於線程同步，需要牢牢記住的第四點是：多個線程訪問共享資源的代碼有可能是同一份代碼，也有可能是不同的代碼；無論是否執行同一份代碼，只要這些線程的代碼訪問同一份可變的共享資源，這些線程之間就需要同步。

為了加深理解，下面舉幾個例子
有兩個采購員，他們的工作內容是相同的，都是遵循如下的步驟：
（1）到市場上去，尋找並購買有潛力的樣品。
（2）回到公司，寫報告。
這兩個人的工作內容雖然一樣，他們都需要購買樣品，他們可能買到同樣種類的樣品，但是他們絕對不會購買到同一件樣品，他們之間沒有任何共享資源。所以，他們可以各自進行自己的工作，互不幹擾。這兩個采購員就相當於兩個線程；兩個采購員遵循相同的工作步驟，相當於這兩個線程執行同一段代碼。

下面給這兩個采購員增加一個工作步驟。采購員需要根據公司的「布告欄」上面公布的信息，安排自己的工作計劃。 這兩個采購員有可能同時走到布告欄的前面，同時觀看布告欄上的信息。這一點問題都沒有。因為布告欄是只讀的，這兩個采購員誰都不會去修改布告欄上寫的信息 下面增加一個角色。一個辦公室行政人員這個時候，也走到了布告欄前面，准備修改布告欄上的信息。

如果行政人員先到達布告欄，並且正在修改布告欄的內容。兩個采購員這個時候，恰好也到了。這兩個采購員就必須等待行政人員完成修改之後，才能觀看修改後的信息。

如果行政人員到達的時候，兩個采購員已經在觀看布告欄了。那麼行政人員需要等待兩個采購員把當前信息記錄下來之後，才能夠寫上新的信息。

上述這兩種情況，行政人員和采購員對布告欄的訪問就需要進行同步。因為其中一個線程（行政人員）修改了共享資源（布告欄）。而且我們可以看到，行政人員的工作流程和采購員的工作流程（執行代碼）完全不同，但是由於他們訪問了同一份可變共享資源（布告欄），所以他們之間需要同步。

同步鎖
前面講了為什麼要線程同步，下面我們就來看如何才能線程同步。
線程同步的基本實現思路還是比較容易理解的。我們可以給共享資源加一把鎖，這把鎖只有一把鑰匙。哪個線程獲取了這把鑰匙，才有權利訪問該共享資源。

生活中，我們也可能會遇到這樣的例子。一些超市的外面提供了一些自動儲物箱。每個儲物箱都有一把鎖，一把鑰匙。人們可以使用那些帶有鑰匙的儲物箱，把東西放到儲物箱裡面，把儲物箱鎖上，然後把鑰匙拿走。這樣，該儲物箱就被鎖住了，其他人不能再訪問這個儲物箱。（當然，真實的儲物箱鑰匙是可以被人拿走復制的，所以不要把貴重物品放在超市的儲物箱裡面。於是很多超市都採用了電子密碼鎖。）

線程同步鎖這個模型看起來很直觀。但是，還有一個嚴峻的問題沒有解決，這個同步鎖應該加在哪裡？ 當然是加在共享資源上了。反應快的讀者一定會搶先回答。

沒錯，如果可能，我們當然盡量把同步鎖加在共享資源上。一些比較完善的共享資源，比如，文件系統，資料庫系統等，自身都提供了比較完善的同步鎖機制。我們不用另外給這些資源加鎖，這些資源自己就有鎖。

但是，大部分情況下，我們在代碼中訪問的共享資源都是比較簡單的共享對象。這些對象裡面沒有地方讓我們加鎖。

讀者可能會提出建議：為什麼不在每一個對象內部都增加一個新的區域，專門用來加鎖呢？這種設計理論上當然也是可行的。問題在於，線程同步的情況並不是很普遍。如果因為這小概率事件，在所有對象內部都開辟一塊鎖空間，將會帶來極大的空間浪費。得不償失。

於是，現代的編程語言的設計思路都是把同步鎖加在代碼段上。確切的說，是把同步鎖加在「訪問共享資源的代碼段」上。這一點一定要記住，同步鎖是加在代碼段上的。

同步鎖加在代碼段上，就很好地解決了上述的空間浪費問題。但是卻增加了模型的復雜度，也增加了我們的理解難度。

❷ java 執行線程的方法是( )

先是start啟動線程，真正執行是run（）

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

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

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

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

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

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

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

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

❹ 如何創建並運行Java線程

Java線程類也是一個object類,它的實例都繼承自java.lang.Thread或其子類。 可以用如下方式用java中創建一個線程：

Tread thread = new Thread();

執行該線程可以調用該線程的start()方法:

thread.start();

在上面的例子中，我們並沒有為線程編寫運行代碼，因此調用該方法後線程就終止了。

編寫線程運行時執行的代碼有兩種方式：一種是創建Thread子類的一個實例並重寫run方法，第二種是創建類的時候實現Runnable介面。接下來我們會具體講解這兩種方法：

創建Thread的子類

創建Thread子類的一個實例並重寫run方法，run方法會在調用start()方法之後被執行。例子如下：

public class MyThread extends Thread {
public void run(){
System.out.println("MyThread running");
}
}

可以用如下方式創建並運行上述Thread子類

MyThread myThread = new MyThread();
myTread.start();

一旦線程啟動後start方法就會立即返回，而不會等待到run方法執行完畢才返回。就好像run方法是在另外一個cpu上執行一樣。當run方法執行後，將會列印出字元串MyThread running。

你也可以如下創建一個Thread的匿名子類：

Thread thread = new Thread(){
public void run(){
System.out.println("Thread Running");
}
};
thread.start();

當新的線程的run方法執行以後，計算機將會列印出字元串」Thread Running」。

實現Runnable介面

第二種編寫線程執行代碼的方式是新建一個實現了java.lang.Runnable介面的類的實例，實例中的方法可以被線程調用。下面給出例子：

public class MyRunnable implements Runnable {
public void run(){
System.out.println("MyRunnable running");
}
}

為了使線程能夠執行run()方法，需要在Thread類的構造函數中傳入 MyRunnable的實例對象。示例如下：

Thread thread = new Thread(new MyRunnable());
thread.start();

當線程運行時，它將會調用實現了Runnable介面的run方法。上例中將會列印出」MyRunnable running」。

同樣，也可以創建一個實現了Runnable介面的匿名類，如下所示：

Runnable myRunnable = new Runnable(){
public void run(){
System.out.println("Runnable running");
}
}
Thread thread = new Thread(myRunnable);
thread.start();

創建子類還是實現Runnable介面？

對於這兩種方式哪種好並沒有一個確定的答案，它們都能滿足要求。就我個人意見，我更傾向於實現Runnable介面這種方法。因為線程池可以有效的管理實現了Runnable介面的線程，如果線程池滿了，新的線程就會排隊等候執行，直到線程池空閑出來為止。而如果線程是通過實現Thread子類實現的，這將會復雜一些。

有時我們要同時融合實現Runnable介面和Thread子類兩種方式。例如，實現了Thread子類的實例可以執行多個實現了Runnable介面的線程。一個典型的應用就是線程池。

常見錯誤：調用run()方法而非start()方法

創建並運行一個線程所犯的常見錯誤是調用線程的run()方法而非start()方法，如下所示：

Thread newThread = new Thread(MyRunnable());
newThread.run(); //should be start();

起初你並不會感覺到有什麼不妥，因為run()方法的確如你所願的被調用了。但是，事實上,run()方法並非是由剛創建的新線程所執行的，而是被創建新線程的當前線程所執行了。也就是被執行上面兩行代碼的線程所執行的。想要讓創建的新線程執行run()方法，必須調用新線程的start方法。

線程名

當創建一個線程的時候，可以給線程起一個名字。它有助於我們區分不同的線程。例如：如果有多個線程寫入System.out，我們就能夠通過線程名容易的找出是哪個線程正在輸出。例子如下：

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable, "New Thread");
thread.start();
System.out.println(thread.getName());

需要注意的是，因為MyRunnable並非Thread的子類，所以MyRunnable類並沒有getName()方法。可以通過以下方式得到當前線程的引用：

Thread.currentThread();

因此，通過如下代碼可以得到當前線程的名字：

String threadName = Thread.currentThread().getName();

線程代碼舉例：

這里是一個小小的例子。首先輸出執行main()方法線程名字。這個線程JVM分配的。然後開啟10個線程，命名為1~10。每個線程輸出自己的名字後就退出。

public class ThreadExample {
public static void main(String[] args){
System.out.println(Thread.currentThread().getName());
for(int i=0; i<10; i++){
new Thread("" + i){
public void run(){
System.out.println("Thread: " + getName() + "running");
}
}.start();
}
}
}

需要注意的是，盡管啟動線程的順序是有序的，但是執行的順序並非是有序的。也就是說，1號線程並不一定是第一個將自己名字輸出到控制台的線程。這是因為線程是並行執行而非順序的。Jvm和操作系統一起決定了線程的執行順序，他和線程的啟動順序並非一定是一致的。

❺ Java中某一特定線程的具體任務在哪個方法中執行

這個程序的執行順序不不一定的，它的執行順序還跟線程分的時間片有關
CPU運算的時間 是分時間片 分給不同的線程的 一個線程執行完 或者用完了當前它分到的那個時間片 他就得讓出CPU給其他線程使用啦！
線程化是允許多個活動共存於一個進程中的工具。大多數現代的操作系統都支持線程，而且線程的概念以各種形式已存在了好多年。Java 是第一個在語言本身中顯式地包含線程的主流編程語言，它沒有把線程化看作是底層操作系統的工具。
有時候，線程也稱作輕量級進程。就象進程一樣，線程在程序中是獨立的、並發的執行路徑，每個線程有它自己的堆棧、自己的程序計數器和自己的局部變數。但是，與分隔的進程相比，進程中的線程之間的隔離程度要小。它們共享內存、文件句柄和其它每個進程應有的狀態。
進程可以支持多個線程，它們看似同時執行，但互相之間並不同步。一個進程中的多個線程共享相同的內存地址空間，這就意味著它們可以訪問相同的變數和對象，而且它們從同一堆中分配對象。盡管這讓線程之間共享信息變得更容易，但您必須小心，確保它們不會妨礙同一進程里的其它線程。
Java 線程工具和 API 看似簡單。但是，編寫有效使用線程的復雜程序並不十分容易。因為有多個線程共存在相同的內存空間中並共享相同的變數，所以您必須小心，確保您的線程不會互相干擾。
每個 Java 程序都使用線程
每個 Java 程序都至少有一個線程 ― 主線程。當一個 Java 程序啟動時，JVM 會創建主線程，並在該線程中調用程序的 main() 方法。
JVM 還創建了其它線程，您通常都看不到它們 ― 例如，與垃圾收集、對象終止和其它 JVM 內務處理任務相關的線程。其它工具也創建線程，如 AWT（抽象窗口工具箱（Abstract Windowing Toolkit））或 Swing UI 工具箱、servlet 容器、應用程序伺服器和 RMI（遠程方法調用（Remote Method Invocation））。

❻ 如何創建並運行java線程

1
2
3
4
5
6
7
8
9
10
11

創建線程，就是這樣
extends Thread 或者 implements Runnable，但是有很多問題；

所以引申出了下面的線程池
Java通過Executors提供四種線程池，分別為：
newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，
若無可回收，則新建線程。
newFixedThreadPool 創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。
newScheledThreadPool 創建一個定長線程池，支持定時及周期性任務執行。
newSingleThreadExecutor 創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，
保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

❼ java線程執行完後自己結束嗎

其實最佳答案的說法是有問題的，如果題主指的結束，是指方法塊語句的執行結束的話，熱心網友的說法是對的。但是對於線程本身，所有線程（包括主線程）在啟動後都被CPU參照優先順序交替調用，運行的順序是無法預測的，但最後結束的一定是主線程。
網上有部分說法，展示的代碼運行結果，「主線程先於其他線程結束，並不影響其他線程的運行」只有後半部分是對的。因為方法體（不管是自定義線程的run()還是主線程的main()）中全部語句的執行完畢不代表所在線程的結束，可以用activeCount()返回當前運行的匯流排程數來驗證這一點。另外，如果將自定義的線程對象設定為守護線程（setDeamon()）,也可以很清楚看到即便main()方法中最後一句輸出語句執行完畢，控制台仍會根據該自定義線程run()方法體的內容繼續輸出，這證明主線程還沒結束——因為當線程組中只剩下守護線程時，JVM虛擬機會自動退出，如果主線程已經結束，唯一活動的線程在被設置成守護線程的情況下，程序會直接結束運行，不可能繼續輸出。

❽ 請問java中多線程的執行順序是怎樣的

thread類是被繼承的，執行的時候調用的是繼承它的子類，但java一般實現多線程不是繼承thread類，而是實現runnable介面，因為java不能多重繼承，所以繼承thread類後就不能繼承別的類了。
只要實現runnable介面（或繼承了thread類）就可以實現多線程。
比如說有a
b
c
d
e五個類都實現runnable介面（或繼承了thread類）
你先進了main方法，就創建了一個線程，這個線程是main方法的
你調用a的run（）方法，就又創建一個線程，這個線程是a方法的。
如果還不懂得話建議你去看看什麼叫繼承和介面，基礎差的話理解起來有點困難
我可是辛辛苦苦打字半天了～～～

❾ java 線程池是怎麼處理執行線程的

java中線程池的監控可以檢測到正在執行的線程數。
通過線程池提供的參數進行監控。線程池裡有一些屬性在監控線程池的時候可以使用
taskCount：線程池需要執行的任務數量。
completedTaskCount：線程池在運行過程中已完成的任務數量。小於或等於taskCount。
largestPoolSize：線程池曾經創建過的最大線程數量。通過這個數據可以知道線程池是否滿過。如等於線程池的最大大小，則表示線程池曾經滿了。
getPoolSize:線程池的線程數量。如果線程池不銷毀的話，池裡的線程不會自動銷毀，所以這個大小隻增不+ getActiveCount：獲取活動的線程數。
通過擴展線程池進行監控。通過繼承線程池並重寫線程池的beforeExecute，afterExecute和terminated方法，我們可以在任務執行前，執行後和線程池關閉前干一些事情。如監控任務的平均執行時間，最大執行時間和最小執行時間等。這幾個方法在線程池裡是空方法。

❿ java中多線程程序是怎樣執行的

Thread.start()只是代表啟動了一個線程，什麼時候執行這要依賴於操作系統對CPU時間片的分配，另外啟動一個線程是需要資源的，所以肯定會存在延遲，為什麼會執行「測試二」，搞清楚，這里已經是兩個線程了，一個線程是t，另外一個線程是主線程，也就是創建NewThread的線程。所以，t怎麼會阻礙主線程的運行呢？