java幾種多線程

A. java多線程有幾種實現方法線程之間如何同步

Java多線程有兩種實現方式：一種是繼承Thread類，另一種是實現Runable介面，大同小異，推薦後者，因為實現介面的話這個類還可以實現別的介面和繼承一個類，靈活性好，若繼承Thread類之後，就無法繼承其他類了。
至於實現同步，最簡單的方法就是使用同步塊，synchronized(){語句塊}
當多個線程同時訪問到同步語句塊時，會由一個線程先獲得對象鎖，獲取對象鎖的線程執行完畢之後，釋放鎖，其他線程再次競爭鎖，一個一個通過，不存在兩個以上線程同時執行同步語句塊的情況。

B. 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資源交給下一個線程執行。

C. java多線程都有幾種方式實現

有三種：
(1)繼承Thread類，重寫run函數
創建：
class xx extends Thread{
public void run(){
Thread.sleep(1000) //線程休眠1000毫秒，sleep使線程進入Block狀態，並釋放資源
}}
開啟線程：
對象.start() //啟動線程，run函數運行
(2)實現Runnable介面，重寫run函數
開啟線程：
Thread t = new Thread(對象) //創建線程對象
t.start()
(3)實現Callable介面，重寫call函數
Callable是類似於Runnable的介面，實現Callable介面的類和實現Runnable的類都是可被其它線程執行的任務。
Callable和Runnable有幾點不同:
①Callable規定的方法是call()，而Runnable規定的方法是run().
②Callable的任務執行後可返回值，而Runnable的任務是不能返回值的
③call()方法可拋出異常，而run()方法是不能拋出異常的。
④運行Callable任務可拿到一個Future對象，Future表示非同步計算的結果。它提供了檢查計算是否完成的方法,以等
待計算的完成,並檢索計算的結果.通過Future對象可了解任務執行情況,可取消任務的執行,還可獲取任務執行的結果

D. java澶氱嚎紼嬫嗘灦鏈夊摢浜

Java澶氱嚎紼嬫嗘灦涓昏佹湁浠ヤ笅鍑犵嶏細

1. Java鍘熺敓綰跨▼妗嗘灦

Java璇璦鏈韜鎻愪緵浜嗗氱嚎紼嬬殑鍘熺敓鏀鎸侊紝閫氳繃java.lang.Thread綾諱互鍙妀ava.util.concurrent鍖呬腑鐨勪竴緋誨垪綾繪潵瀹炵幇澶氱嚎紼嬬紪紼嬨傚叾涓錛孴hread綾繪槸Java涓鏈鍩烘湰鐨勭嚎紼嬬被錛屽彲浠ラ氳繃緇ф壙Thread綾繪垨浣跨敤瀹炵幇Runnable鎺ュ彛鐨勬柟寮忓壋寤虹嚎紼嬨傛ゅ栵紝java.util.concurrent鍖呮彁渚涗簡涓緋誨垪鏀鎸佸苟鍙戠紪紼嬬殑宸ュ叿綾伙紝濡侲xecutorService銆丆ountDownLatch絳夈

2. Spring妗嗘灦涓鐨勫氱嚎紼嬫敮鎸

Spring妗嗘灦鎻愪緵浜嗗瑰氱嚎紼嬬紪紼嬬殑鑹濂芥敮鎸侊紝涓昏佷綋鐜板湪Spring鐨勪換鍔¤皟搴︽嗘灦涓銆傞氳繃Spring鐨凾askExecutor鎺ュ彛錛屽彲浠ユ柟渚垮湴榪涜屼換鍔¤皟搴﹀拰綰跨▼奼犵＄悊銆傛ゅ栵紝Spring榪樻彁渚涗簡娉ㄨВ椹卞姩鐨勫紓姝ユ柟娉曟墽琛岋紝閫氳繃@Async娉ㄨВ鍙浠ヨ交鏉懼湴瀹炵幇寮傛ュ勭悊銆

3. Java騫跺彂鍖卝ava.util.concurrent

java.util.concurrent鍖呮槸Java鏍囧噯搴撲腑涓涓閲嶈佺殑騫跺彂宸ュ叿鍖咃紝鎻愪緵浜嗗氱嶅苟鍙戠紪紼嬬殑宸ュ叿綾匯傚叾涓錛岀嚎紼嬫睜鐩稿叧鐨勭被濡俆hreadPoolExecutor銆丼cheledThreadPoolExecutor絳夎騫挎硾搴旂敤浜庡氱嚎紼嬬紪紼嬩腑銆傛ゅ栵紝璇ュ寘榪樻彁渚涗簡騫跺彂闆嗗悎綾伙紝鍙浠ユ湁鏁堝湴澶勭悊騫跺彂璁塊棶闂棰樸

4. Java澶氱嚎紼嬫嗘灦Apache MINA鍜孨etty

Apache MINA鍜孨etty鏄疛ava涓甯哥敤鐨勭綉緇滅紪紼嬫嗘灦錛屽畠浠涔熸彁渚涗簡瀵瑰氱嚎紼嬬紪紼嬬殑鏀鎸併傝繖涓や釜妗嗘灦閮藉熀浜庡紓姝ヤ簨浠墮┍鍔ㄦā鍨嬶紝鍙浠ユ湁鏁堝湴澶勭悊楂樺苟鍙戠綉緇滆繛鎺ュ拰鏁版嵁浼犺緭銆傚叾涓錛孨etty鏄涓涓楂樻ц兘鐨勫紓姝ヤ簨浠墮┍鍔ㄧ殑緗戠粶搴旂敤妗嗘灦錛屽箍娉涘簲鐢ㄤ簬寮鍙戠綉緇滄湇鍔″拰鍒嗗竷寮忕郴緇熴

浠ヤ笂榪欎簺Java澶氱嚎紼嬫嗘灦鍚勬湁鐗圭偣錛岄傜敤浜庝笉鍚岀殑搴旂敤鍦烘櫙銆傚紑鍙戣呭彲浠ユ牴鎹鍏蜂綋闇奼傞夋嫨鍚堥傜殑妗嗘灦鏉ュ疄鐜板氱嚎紼嬬紪紼嬨

E. 在Java 中多線程的實現方法有哪些，如何使用～～～～～～～～～～～～～～～～～～急

1、 認識Thread和Runnable

Java中實現多線程有兩種途徑：繼承Thread類或者實現Runnable介面。Runnable是介面，建議用介面的方式生成線程，因為介面可以實現多繼承，況且Runnable只有一個run方法，很適合繼承。在使用Thread的時候只需繼承Thread，並且new一個實例出來，調用start()方法即可以啟動一個線程。

Thread Test = new Thread();

Test.start();

在使用Runnable的時候需要先new一個實現Runnable的實例，之後啟動Thread即可。

Test impelements Runnable;

Test t = new Test();

Thread test = new Thread(t);

test.start();

總結：Thread和Runnable是實現java多線程的2種方式，runable是介面，thread是類，建議使用runable實現java多線程，不管如何，最終都需要通過thread.start()來使線程處於可運行狀態。

2、 認識Thread的start和run

1） start：

用start方法來啟動線程，真正實現了多線程運行，這時無需等待run方法體代碼執行完畢而直接繼續執行下面的代碼。通過調用Thread類的start()方法來啟動一個線程，這時此線程處於就緒（可運行）狀態，並沒有運行，一旦得到spu時間片，就開始執行run()方法，這里方法run()稱為線程體，它包含了要執行的這個線程的內容，Run方法運行結束，此線程隨即終止。

2） run：

run()方法只是類的一個普通方法而已，如果直接調用Run方法，程序中依然只有主線程這一個線程，其程序執行路徑還是只有一條，還是要順序執行，還是要等待run方法體執行完畢後才可繼續執行下面的代碼，這樣就沒有達到寫線程的目的。

總結：調用start方法方可啟動線程，而run方法只是thread的一個普通方法調用，還是在主線程里執行。

3、 線程狀態說明

線程狀態從大的方面來說，可歸結為：初始狀態、可運行狀態、不可運行狀態和消亡狀態，具體可細分為上圖所示7個狀態，說明如下：

1） 線程的實現有兩種方式，一是繼承Thread類，二是實現Runnable介面，但不管怎樣，當我們new了thread實例後，線程就進入了初始狀態；

2） 當該對象調用了start()方法，就進入可運行狀態；

3） 進入可運行狀態後，當該對象被操作系統選中，獲得CPU時間片就會進入運行狀態；

4） 進入運行狀態後case就比較多，大致有如下情形：

·run()方法或main()方法結束後，線程就進入終止狀態；

·當線程調用了自身的sleep()方法或其他線程的join()方法，就會進入阻塞狀態(該狀態既停止當前線程，但並不釋放所佔有的資源)。當sleep()結束或join()結束後，該線程進入可運行狀態，繼續等待OS分配時間片；

·當線程剛進入可運行狀態(注意，還沒運行)，發現將要調用的資源被鎖牢(synchroniza,lock)，將會立即進入鎖池狀態，等待獲取鎖標記(這時的鎖池裡也許已經有了其他線程在等待獲取鎖標記，這時它們處於隊列狀態，既先到先得)，一旦線程獲得鎖標記後，就轉入可運行狀態，等待OS分配CPU時間片；

·當線程調用wait()方法後會進入等待隊列(進入這個狀態會釋放所佔有的所有資源，與阻塞狀態不同)，進入這個狀態後，是不能自動喚醒的，必須依靠其他線程調用notify()或notifyAll()方法才能被喚醒(由於notify()只是喚醒一個線程，但我們由不能確定具體喚醒的是哪一個線程，也許我們需要喚醒的線程不能夠被喚醒，因此在實際使用時，一般都用notifyAll()方法，喚醒有所線程)，線程被喚醒後會進入鎖池，等待獲取鎖標記。

·當線程調用stop方法，即可使線程進入消亡狀態，但是由於stop方法是不安全的，不鼓勵使用，大家可以通過run方法里的條件變通實現線程的stop。

F. 在Java 中多線程的實現方法有哪些，如何使用

Java多線程的創建及啟動

Java中線程的創建常見有如三種基本形式

1.繼承Thread類，重寫該類的run()方法。

復制代碼

1 class MyThread extends Thread {

2

3 private int i = 0;

4

5 @Override

6 public void run() {

7 for (i = 0; i < 100; i++) {

8 System.out.println(Thread.currentThread().getName() + " " + i);

9 }

10 }

11 }

復制代碼

復制代碼

1 public class ThreadTest {

2

3 public static void main(String[] args) {

4 for (int i = 0; i < 100; i++) {

5 System.out.println(Thread.currentThread().getName() + " " + i);

6 if (i == 30) {

7 Thread myThread1 = new MyThread(); // 創建一個新的線程 myThread1 此線程進入新建狀態

8 Thread myThread2 = new MyThread(); // 創建一個新的線程 myThread2 此線程進入新建狀態

9 myThread1.start(); // 調用start()方法使得線程進入就緒狀態

10 myThread2.start(); // 調用start()方法使得線程進入就緒狀態

11 }

12 }

13 }

14 }

復制代碼

如上所示，繼承Thread類，通過重寫run()方法定義了一個新的線程類MyThread，其中run()方法的方法體代表了線程需要完成的任務，稱之為線程執行體。當創建此線程類對象時一個新的線程得以創建，並進入到線程新建狀態。通過調用線程對象引用的start()方法，使得該線程進入到就緒狀態，此時此線程並不一定會馬上得以執行，這取決於CPU調度時機。

2.實現Runnable介面，並重寫該介面的run()方法，該run()方法同樣是線程執行體，創建Runnable實現類的實例，並以此實例作為Thread類的target來創建Thread對象，該Thread對象才是真正的線程對象。

復制代碼

1 class MyRunnable implements Runnable {

2 private int i = 0;

3

4 @Override

5 public void run() {

6 for (i = 0; i < 100; i++) {

7 System.out.println(Thread.currentThread().getName() + " " + i);

8 }

9 }

10 }

復制代碼

復制代碼

1 public class ThreadTest {

2

3 public static void main(String[] args) {

4 for (int i = 0; i < 100; i++) {

5 System.out.println(Thread.currentThread().getName() + " " + i);

6 if (i == 30) {

7 Runnable myRunnable = new MyRunnable(); // 創建一個Runnable實現類的對象

8 Thread thread1 = new Thread(myRunnable); // 將myRunnable作為Thread target創建新的線程

9 Thread thread2 = new Thread(myRunnable);

10 thread1.start(); // 調用start()方法使得線程進入就緒狀態

11 thread2.start();

12 }

13 }

14 }

15 }

復制代碼

相信以上兩種創建新線程的方式大家都很熟悉了，那麼Thread和Runnable之間到底是什麼關系呢？我們首先來看一下下面這個例子。

復制代碼

1 public class ThreadTest {

2

3 public static void main(String[] args) {

4 for (int i = 0; i < 100; i++) {

5 System.out.println(Thread.currentThread().getName() + " " + i);

6 if (i == 30) {

7 Runnable myRunnable = new MyRunnable();

8 Thread thread = new MyThread(myRunnable);

9 thread.start();

10 }

11 }

12 }

13 }

14

15 class MyRunnable implements Runnable {

16 private int i = 0;

17

18 @Override

19 public void run() {

20 System.out.println("in MyRunnable run");

21 for (i = 0; i < 100; i++) {

22 System.out.println(Thread.currentThread().getName() + " " + i);

23 }

24 }

25 }

26

27 class MyThread extends Thread {

28

29 private int i = 0;

30

31 public MyThread(Runnable runnable){

32 super(runnable);

33 }

34

35 @Override

36 public void run() {

37 System.out.println("in MyThread run");

38 for (i = 0; i < 100; i++) {

39 System.out.println(Thread.currentThread().getName() + " " + i);

40 }

41 }

42 }

復制代碼

同樣的，與實現Runnable介面創建線程方式相似，不同的地方在於

1 Thread thread = new MyThread(myRunnable);

那麼這種方式可以順利創建出一個新的線程么？答案是肯定的。至於此時的線程執行體到底是MyRunnable介面中的run()方法還是MyThread類中的run()方法呢？通過輸出我們知道線程執行體是MyThread類中的run()方法。其實原因很簡單，因為Thread類本身也是實現了Runnable介面，而run()方法最先是在Runnable介面中定義的方法。

1 public interface Runnable {

2

3 public abstract void run();

4

5 }

我們看一下Thread類中對Runnable介面中run()方法的實現：

復制代碼

@Override

public void run() {

if (target != null) {

target.run();

}

}

復制代碼

也就是說，當執行到Thread類中的run()方法時，會首先判斷target是否存在，存在則執行target中的run()方法，也就是實現了Runnable介面並重寫了run()方法的類中的run()方法。但是上述給到的列子中，由於多態的存在，根本就沒有執行到Thread類中的run()方法，而是直接先執行了運行時類型即MyThread類中的run()方法。

3.使用Callable和Future介面創建線程。具體是創建Callable介面的實現類，並實現clall()方法。並使用FutureTask類來包裝Callable實現類的對象，且以此FutureTask對象作為Thread對象的target來創建線程。

看著好像有點復雜，直接來看一個例子就清晰了。

復制代碼

1 public class ThreadTest {

2

3 public static void main(String[] args) {

4

5 Callable<Integer> myCallable = new MyCallable(); // 創建MyCallable對象

6 FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask來包裝MyCallable對象

7

8 for (int i = 0; i < 100; i++) {

9 System.out.println(Thread.currentThread().getName() + " " + i);

10 if (i == 30) {

11 Thread thread = new Thread(ft); //FutureTask對象作為Thread對象的target創建新的線程

12 thread.start(); //線程進入到就緒狀態

13 }

14 }

15

16 System.out.println("主線程for循環執行完畢..");

17

18 try {

19 int sum = ft.get(); //取得新創建的新線程中的call()方法返回的結果

20 System.out.println("sum = " + sum);

21 } catch (InterruptedException e) {

22 e.printStackTrace();

23 } catch (ExecutionException e) {

24 e.printStackTrace();

25 }

26

27 }

28 }

29

30

31 class MyCallable implements Callable<Integer> {

32 private int i = 0;

33

34 // 與run()方法不同的是，call()方法具有返回值

35 @Override

36 public Integer call() {

37 int sum = 0;

38 for (; i < 100; i++) {

39 System.out.println(Thread.currentThread().getName() + " " + i);

40 sum += i;

41 }

42 return sum;

43 }

44

45 }

復制代碼

首先，我們發現，在實現Callable介面中，此時不再是run()方法了，而是call()方法，此call()方法作為線程執行體，同時還具有返回值！在創建新的線程時，是通過FutureTask來包裝MyCallable對象，同時作為了Thread對象的target。那麼看下FutureTask類的定義：

1 public class FutureTask<V> implements RunnableFuture<V> {

2

3 //....

4

5 }

1 public interface RunnableFuture<V> extends Runnable, Future<V> {

2

3 void run();

4

5 }

於是，我們發現FutureTask類實際上是同時實現了Runnable和Future介面，由此才使得其具有Future和Runnable雙重特性。通過Runnable特性，可以作為Thread對象的target，而Future特性，使得其可以取得新創建線程中的call()方法的返回值。

執行下此程序，我們發現sum = 4950永遠都是最後輸出的。而「主線程for循環執行完畢..」則很可能是在子線程循環中間輸出。由CPU的線程調度機制，我們知道，「主線程for循環執行完畢..」的輸出時機是沒有任何問題的，那麼為什麼sum =4950會永遠最後輸出呢？

原因在於通過ft.get()方法獲取子線程call()方法的返回值時，當子線程此方法還未執行完畢，ft.get()方法會一直阻塞，直到call()方法執行完畢才能取到返回值。

上述主要講解了三種常見的線程創建方式，對於線程的啟動而言，都是調用線程對象的start()方法，需要特別注意的是：不能對同一線程對象兩次調用start()方法。

你好，本題已解答,如果滿意

請點右下角「採納答案」。

G. 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()方法，會阻塞直到計算完成。