java實現多線程,Java實現多線程的兩種方式

本文目錄一覽：

1、java多線程方法有哪些
2、多線程的java 程序如何編寫？
3、在Java 中多線程的實現方法有哪些，如何使用
4、java多線程有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼?
5、java多線程有幾種實現方法
6、java 多線程有幾種實現方法

java多線程方法有哪些

java實現線程常用到的方法有三種，供參考：

/**

* 方法一：繼承Thread類

* @author qd

public class MyThread extends Thread {

@Override

public void run() {

System.out.println(“run方法裡面編寫業務代碼”);

}

public static void main(String[] args) {

MyThread myThread = new MyThread();

// 調用start方法啟動線程

myThread.start();

MyThread1 myThread1 = new MyThread1();

Thread thread = new Thread(myThread1);

// 調用start方法啟動線程

thread.start();

}

/**

* 方法二：實現Runnable介面

* @author qd

class MyThread1 implements Runnable {

@Override

public void run() {

System.out.println(“run方法裡面編寫業務代碼”);

}

/**

* 方法三：實現CallableT介面優點：可以傳參數，有返回值類型

* @author qd

class MyThread2 implements CallableInteger {

@Override

public Integer call() throws Exception {

return null;

}

多線程的java 程序如何編寫？

Java 給多線程編程提供了內置的支持。一條線程指的是進程中一個單一順序的控制流，一個進程中可以並發多個線程，每條線程並行執行不同的任務。

新建狀態:

使用 new 關鍵字和 Thread 類或其子類建立一個線程對象後，該線程對象就處於新建狀態。它保持這個狀態直到程序 start() 這個線程。

就緒狀態:

當線程對象調用了start()方法之後，該線程就進入就緒狀態。就緒狀態的線程處於就緒隊列中，要等待JVM里線程調度器的調度。

運行狀態:

如果就緒狀態的線程獲取 CPU 資源，就可以執行 run()，此時線程便處於運行狀態。處於運行狀態的線程最為複雜，它可以變為阻塞狀態、就緒狀態和死亡狀態。

阻塞狀態:

如果一個線程執行了sleep（睡眠）、suspend（掛起）等方法，失去所佔用資源之後，該線程就從運行狀態進入阻塞狀態。在睡眠時間已到或獲得設備資源後可以重新進入就緒狀態。可以分為三種：

等待阻塞：運行狀態中的線程執行 wait() 方法，使線程進入到等待阻塞狀態。

同步阻塞：線程在獲取 synchronized 同步鎖失敗(因為同步鎖被其他線程佔用)。

其他阻塞：通過調用線程的 sleep() 或 join() 發出了 I/O 請求時，線程就會進入到阻塞狀態。當sleep() 狀態超時，join() 等待線程終止或超時，或者 I/O 處理完畢，線程重新轉入就緒狀態。

死亡狀態:

一個運行狀態的線程完成任務或者其他終止條件發生時，該線程就切換到終止狀態。

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

Java多線程的創建及啟動

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

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

複製代碼

1 class MyThread extends Thread {

3 private int i = 0;

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 {

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;

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 {

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 {

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 }

15 class MyRunnable implements Runnable {

16 private int i = 0;

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 }

27 class MyThread extends Thread {

29 private int i = 0;

31 public MyThread(Runnable runnable){

32 super(runnable);

33 }

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 {

3 public abstract void run();

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 {

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

5 CallableInteger myCallable = new MyCallable(); // 創建MyCallable對象

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

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 }

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

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 }

27 }

28 }

31 class MyCallable implements CallableInteger {

32 private int i = 0;

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 }

45 }

複製代碼

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

1 public class FutureTaskV implements RunnableFutureV {

3 //….

5 }

1 public interface RunnableFutureV extends Runnable, FutureV {

3 void run();

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()方法。

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

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

java多線程有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼?

java中多線程的實現方法有兩種：1.直接繼承thread類；2.實現runnable介面；同步的實現方法有五種：1.同步方法；2.同步代碼塊；3.使用特殊域變數(volatile)實現線程同步；4.使用重入鎖實現線程同步；5.使用局部變數實現線程同步

。

其中多線程實現過程中需注意重寫或者覆蓋run()方法，而對於同步的實現方法中使用較常使用的是利用synchronized編寫同步方法和代碼塊。

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 多線程有幾種實現方法

1、繼承Thread類實現多線程

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

[java] view plain copy

public class MyThread extends Thread {

public void run() {

System.out.println(“MyThread.run()”);

}

在合適的地方啟動線程如下：

[java] view plain copy

MyThread myThread1 = new MyThread();

MyThread myThread2 = new MyThread();

myThread1.start();

myThread2.start();

2、實現Runnable介面方式實現多線程

如果自己的類已經extends另一個類，就無法直接extends Thread，此時，必須實現一個Runnable介面，如下：

[java] view plain copy

public class MyThread extends OtherClass implements Runnable {

public void run() {

System.out.println(“MyThread.run()”);

}

為了啟動MyThread，需要首先實例化一個Thread，並傳入自己的MyThread實例：

[java] view plain copy

MyThread myThread = new MyThread();

Thread thread = new Thread(myThread);

thread.start();

事實上，當傳入一個Runnable target參數給Thread後，Thread的run()方法就會調用target.run()，參考JDK源代碼：

[java] view plain copy

public void run() {

if (target != null) {

target.run();

}

3、使用ExecutorService、Callable、Future實現有返回結果的多線程

ExecutorService、Callable、Future這個對象實際上都是屬於Executor框架中的功能類。想要詳細了解Executor框架的可以訪問，這裡面對該框架做了很詳細的解釋。返回結果的線程是在JDK1.5中引入的新特徵，確實很實用，有了這種特徵我就不需要再為了得到返回值而大費周折了，而且即便實現了也可能漏洞百出。

可返回值的任務必須實現Callable介面，類似的，無返回值的任務必須Runnable介面。執行Callable任務後，可以獲取一個Future的對象，在該對象上調用get就可以獲取到Callable任務返回的Object了，再結合線程池介面ExecutorService就可以實現傳說中有返回結果的多線程了。下面提供了一個完整的有返回結果的多線程測試例子，在JDK1.5下驗證過沒問題可以直接使用。

原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/188671.html

java實現多線程,Java實現多線程的兩種方式

本文目錄一覽：

java多線程方法有哪些

多線程的java 程序如何編寫？

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

java多線程有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼?

java多線程有幾種實現方法

java 多線程有幾種實現方法

相關推薦

發表回復