java多線程編程,java多線程編程核心技術第三版pdf

本文目錄一覽：

• 1、java多線程有幾種實現方法
• 2、如何用Java編寫多線程
• 3、java多線程編程中涉及的基礎知識點？
• 4、什麼是多線程編程
• 5、java多線程編程如何控制執行順序
• 6、北大青鳥設計培訓：Java多線程問題總結？

java多線程有幾種實現方法

繼承Thread類來實現多線程:

當我們自定義的類繼承Thread類後，該類就為一個線程類,該類為一個獨立的執行單元，線程代碼必須編寫在run()方法中,run方法是由Thread類定義，我們自己寫的線程類必須重寫run方法。

run方法中定義的代碼為線程代碼，但run方法不能直接調用，如果直接調用並沒有開啟新的線程而是將run方法交給調用的線程執行

要開啟新的線程需要調用Thread類的start()方法，該方法自動開啟一個新的線程並自動執行run方法中的內容

請點擊輸入圖片描述

結果：            

請點擊輸入圖片描述

*java多線程的啟動順序不一定是線程執行的順序，各個線程之間是搶佔CPU資源執行的，所有有可能出現與啟動順序不一致的情況。

CPU的調用策略：

如何使用CPU資源是由操作系統來決定的，但操作系統只能決定CPU的使用策略不能控制實際獲得CPU執行權的程序。

線程執行有兩種方式：

1.搶佔式：

目前PC機中使用最多的一種方式，線程搶佔CPU的執行權，當一個線程搶到CPU的資源後並不是一直執行到此線程執行結束，而是執行一個時間片後讓出CPU資源，此時同其他線程再次搶佔CPU資源獲得執行權。

2.輪循式;

每個線程執行固定的時間片後讓出CPU資源，以此循環執行每個線程執行相同的時間片後讓出CPU資源交給下一個線程執行。

如何用Java編寫多線程

在java中要想實現多線程，有兩種手段，一種是繼續Thread類，另外一種是實現Runable接口。

對於直接繼承Thread的類來說，代碼大致框架是：

?

123456789101112 class 類名 extends Thread{ 方法1; 方法2； … public void run(){ // other code… } 屬性1； 屬性2； … }

先看一個簡單的例子：

?

12345678910111213141516171819202122232425262728 /** * @author Rollen-Holt 繼承Thread類,直接調用run方法 * */class hello extends Thread { public hello() { } public hello(String name) { this.name = name; } public void run() { for (int i = 0; i 5; i++) { System.out.println(name + “運行 ” + i); } } public static void main(String[] args) { hello h1=new hello(“A”); hello h2=new hello(“B”); h1.run(); h2.run(); } private String name; }

【運行結果】：

A運行 0

A運行 1

A運行 2

A運行 3

A運行 4

B運行 0

B運行 1

B運行 2

B運行 3

B運行 4

我們會發現這些都是順序執行的，說明我們的調用方法不對，應該調用的是start（）方法。

當我們把上面的主函數修改為如下所示的時候：

?

123456 public static void main(String[] args) { hello h1=new hello(“A”); hello h2=new hello(“B”); h1.start(); h2.start(); }

然後運行程序，輸出的可能的結果如下：

A運行 0

B運行 0

B運行 1

B運行 2

B運行 3

B運行 4

A運行 1

A運行 2

A運行 3

A運行 4

因為需要用到CPU的資源，所以每次的運行結果基本是都不一樣的，呵呵。

注意：雖然我們在這裡調用的是start（）方法，但是實際上調用的還是run（）方法的主體。

那麼：為什麼我們不能直接調用run（）方法呢？

我的理解是：線程的運行需要本地操作系統的支持。

如果你查看start的源代碼的時候，會發現：

?

1234567891011121314151617 public synchronized void start() { /** * This method is not invoked for the main method thread or “system” * group threads created/set up by the VM. Any new functionality added * to this method in the future may have to also be added to the VM. * * A zero status value corresponds to state “NEW”. */ if (threadStatus != 0 || this != me) throw new IllegalThreadStateException(); group.add(this); start0(); if (stopBeforeStart) { stop0(throwableFromStop); } } private native void start0();

注意我用紅色加粗的那一條語句，說明此處調用的是start0（）。並且這個這個方法用了native關鍵字，次關鍵字表示調用本地操作系統的函數。因為多線程的實現需要本地操作系統的支持。

但是start方法重複調用的話，會出現java.lang.IllegalThreadStateException異常。

通過實現Runnable接口：

大致框架是：

?

123456789101112 class 類名 implements Runnable{ 方法1; 方法2； … public void run(){ // other code… } 屬性1； 屬性2； … }

來先看一個小例子吧：

?

123456789101112131415161718192021222324252627282930 /** * @author Rollen-Holt 實現Runnable接口 * */class hello implements Runnable { public hello() { } public hello(String name) { this.name = name; } public void run() { for (int i = 0; i 5; i++) { System.out.println(name + “運行 ” + i); } } public static void main(String[] args) { hello h1=new hello(“線程A”); Thread demo= new Thread(h1); hello h2=new hello(“線程B”); Thread demo1=new Thread(h2); demo.start(); demo1.start(); } private String name; }

【可能的運行結果】：

線程A運行 0

線程B運行 0

線程B運行 1

線程B運行 2

線程B運行 3

線程B運行 4

線程A運行 1

線程A運行 2

線程A運行 3

線程A運行 4

關於選擇繼承Thread還是實現Runnable接口？

其實Thread也是實現Runnable接口的：

?

12345678 class Thread implements Runnable { //… public void run() { if (target != null) { target.run(); } } }

其實Thread中的run方法調用的是Runnable接口的run方法。不知道大家發現沒有，Thread和Runnable都實現了run方法，這種操作模式其實就是代理模式。關於代理模式，我曾經寫過一個小例子呵呵，大家有興趣的話可以看一下：

Thread和Runnable的區別：

如果一個類繼承Thread，則不適合資源共享。但是如果實現了Runable接口的話，則很容易的實現資源共享。

?

1234567891011121314151617181920212223 /** * @author Rollen-Holt 繼承Thread類，不能資源共享 * */class hello extends Thread { public void run() { for (int i = 0; i 7; i++) { if (count 0) { System.out.println(“count= ” + count–); } } } public static void main(String[] args) { hello h1 = new hello(); hello h2 = new hello(); hello h3 = new hello(); h1.start(); h2.start(); h3.start(); } private int count = 5; }

【運行結果】：

count= 5

count= 4

count= 3

count= 2

count= 1

count= 5

count= 4

count= 3

count= 2

count= 1

count= 5

count= 4

count= 3

count= 2

count= 1

大家可以想象，如果這個是一個買票系統的話，如果count表示的是車票的數量的話，說明並沒有實現資源的共享。

我們換為Runnable接口：

?

12345678910111213141516171819 /** * @author Rollen-Holt 繼承Thread類，不能資源共享 * */class hello implements Runnable { public void run() { for (int i = 0; i 7; i++) { if (count 0) { System.out.println(“count= ” + count–); } } } public static void main(String[] args) { hello he=new hello(); new Thread(he).start(); } private int count = 5; }

【運行結果】：

count= 5

count= 4

count= 3

count= 2

count= 1

總結一下吧：

實現Runnable接口比繼承Thread類所具有的優勢：

1）：適合多個相同的程序代碼的線程去處理同一個資源

2）：可以避免java中的單繼承的限制

3）：增加程序的健壯性，代碼可以被多個線程共享，代碼和數據獨立。

所以，本人建議大家勁量實現接口。

?

java多線程編程中涉及的基礎知識點？

線程設計在軟件開發領域中是非常常見的一個設計構成，今天昆明北大青鳥就一起來了解一下，java多線程編程中都涉及到了哪些基礎知識點。

順序

用於表示多個操作“依次處理”。比如把十個操作交給一個人來處理時，這個人要一個一個地按順序來處理

並行

用於標識多個操作“同時處理”。比如十個操作分給兩個人處理時，這兩個人就會並行來處理。

並發

相對於順序和並行來說比較抽象，用於表示“將一個操作分割成多個部分並且允許無序處理”。比如將十個操作分成相對獨立的兩類，這樣便能夠開始並發處理了。如果一個人來處理，這個人就是順序處理分開的並發操作，而如果是兩個人，這兩個人就可以並行處理同一個操作。

總結

多線程程序都是並發處理的。如果CPU只有一個，那麼並發處理就是順序執行的，而如果有多個CPU，那麼並發處理就可能會並行運行。

等待隊列

所有實例都擁有一個等待隊列，它是在實例的wait方法執行後停止操作的線程隊列。就好比為每個實例準備的線程休息室

在執行wait方法後，線程便會暫停操作，進入等待隊列這個休息室。除非發生下列某一情況，否則線程會一直在等待隊列中休眠。

有其他線程的notify方法來喚醒線程

有其他線程的notifyAll方法來喚醒線程

有其他線程的interrupt方法來喚醒線程

wait方法超時

notify方法

該方法會將等待隊列中的一個線程去除。同wait方法一樣，若要執行notify方法，線程也必須持有要調用的實例的鎖。

notifyAll方法

notify方法僅喚醒一個線程，而notifyAll則喚醒所有線程，這是兩者之間的區別

同wait方法和notify方法一樣，notifyAll方法也只能由持有要調用的實例鎖的線程調用

notify和notifyAll選擇

notify方法和notifyAll方法非常相似，到底該使用哪個?

實際上，這很難選擇，由於notify喚醒的線程較少，所以處理速度要比使用notifyAll時快。但使用notify時，如果處理不好，程序便可能會停止。一般來說，使用notifyAll時的代碼要比使用notify時的更為健壯。

什麼是多線程編程

多線程編程技術是Java語言的重要特點。多線程編程的含義是將程序任務分成幾個並行的子任務。特別是在網絡編程中，你會發現很多功能是可以並發執行的。比如網絡傳輸速度較慢、用戶輸入速度較慢，你可以用兩個獨立的線程去完成這兩個功能，而不影響正常的顯示或其它功能。多線程是與單線程比較而言的，普通的Windows採用單線程程序結構，其工作原理是：主程序有一個消息循環，不斷從消息隊列中讀入消息來決定下一步所要乾的事情，一般是針對一個函數，只有等這個函數執行完之後，主程序才能接收另外的消息來執行。比如子函數功能是在讀一個網絡數據，或讀一個文件，只有等讀完這個數據或文件才能接收下一個消息。在執行這個子函數過程中你什麼也不能幹。但往往讀網絡數據和等待用戶輸入有很多時間處於等待狀態，多線程利用這個特點將任務分成多個並發任務後，就可以解決這個問題。Java中的線程類1.擴展java.lang.Thread類，用它覆蓋Thread類的run方法。2.生成實現java.lang.Runnable接口的類並將其它的實例與java.lang.Thread實例相關聯。Thread類是負責向其它類提供線程支持的最主要的類，要使用一個類具有線程功能，在Java中只要簡單地從Thread類派生一個子類就可以了擴展Thread類，如printThread.java。Thread類最重要的方法是run方法。run方法是新線程執行的方法，因此生成java.lang.Thread的子類時，必須有相應的run方法。//PrintThread.javapublic class PrintThread extends Thread//繼承Tread類private int count=0//定義一個count變量用於統計打印的次數並共享變量public static void mainString args//main方法開始PrintThread p=new PrintThread//創建一個線程實例p.start//執行線程for{;;}//主線程main方法執行一個循環，for執行一個死循環count++System.out.printcount+″：Main\n″//主線程中打印count+“main”變量的值，並換行public void run//線程類必須有的run（）方法for{;;}count++System.out.printcount+″：Thread\n″上面這段程序便是繼承java.lang.Tread並覆蓋run的方法。用Java虛擬機啟動程序時，這個程序會先生成一個線程並調用程序主類的main方法。這個程序中的main方法生成新線程，連接打印“Thread”。在啟動線程之後，主線程繼續打印“Main”。編譯並執行這個程序，然後立即按“Ctrl+C”鍵中斷程序，你會看到上面所述的兩個線程不斷打印出：XXX：main…..XXX：Thread….XXX代表的是數字，也就是上面count的值。在筆者的機器上，不同時刻這兩個線程打印的次數不一樣，先打印20個main（也就是先執行20次主線程）再打印出50次Thread，然後再打印main……提示：為了便於查看該程序的執行結果，你可以將執行結果導入一個文本文件，然後打開這個文件查看各線程執行的情況。如運行：javac PrintThread.javaJava PrintThread1.txt第一個命令javacPrintThread.java是編譯java程序，第二個是執行該程序並將結果導入1.txt文件。當然你可以直接執行命令：java

java多線程編程如何控制執行順序

thread類是被繼承的，執行的時候調用的是繼承它的子類，但java一般實現多線程不是繼承thread類，而是實現runnable接口，因為java不能多重繼承，所以繼承thread類後就不能繼承別的類了。

只要實現runnable接口（或繼承了thread類）就可以實現多線程。

比如說有a b c d e五個類都實現runnable接口（或繼承了thread類）

你先進了main方法，就創建了一個線程，這個線程是main方法的

你調用a的run（）方法，就又創建一個線程，這個線程是a方法的。

如果還不懂得話建議你去看看什麼叫繼承和接口，基礎差的話理解起來有點困難

北大青鳥設計培訓：Java多線程問題總結？

Java多線程分類中寫了21篇多線程的文章，21篇文章的內容很多，個人認為，學習，內容越多、越雜的知識，越需要進行深刻的總結，這樣才能記憶深刻，將知識變成自己的。

java課程培訓機構認為這篇文章主要是對多線程的問題進行總結的，因此羅列了多個多線程的問題。

這些多線程的問題，有些來源於各大網站、有些來源於自己的思考。

（1）發揮多核CPU的優勢隨着工業的進步，現在的筆記本、台式機乃至商用的應用服務器至少也都是雙核的，4核、8核甚至16核的也都不少見，如果是單線程的程序，那麼在雙核CPU上就浪費了50%，在4核CPU上就浪費了75%。

單核CPU上所謂的”多線程”那是假的多線程，同一時間處理器只會處理一段邏輯，只不過線程之間切換得比較快，看着像多個線程”同時”運行罷了。

多核CPU上的多線程才是真正的多線程，它能讓你的多段邏輯同時工作，多線程，可以真正發揮出多核CPU的優勢來，達到充分利用CPU的目的。

（2）防止阻塞從程序運行效率的角度來看，單核CPU不但不會發揮出多線程的優勢，反而會因為在單核CPU上運行多線程導致線程上下文的切換，而降低程序整體的效率。

但是單核CPU我們還是要應用多線程，就是為了防止阻塞。

試想，如果單核CPU使用單線程，那麼只要這個線程阻塞了，比方說遠程讀取某個數據吧，對端遲遲未返回又沒有設置超時時間，那麼你的整個程序在數據返回回來之前就停止運行了。

多線程可以防止這個問題，多條線程同時運行，哪怕一條線程的代碼執行讀取數據阻塞，也不會影響其它任務的執行。

（3）便於建模這是另外一個沒有這麼明顯的優點了。

假設有一個大的任務A，單線程編程，那麼就要考慮很多，建立整個程序模型比較麻煩。

但是如果把這個大的任務A分解成幾個小任務，任務B、任務C、任務D，分別建立程序模型，並通過多線程分別運行這幾個任務，那就簡單很多了。