java多線程高級用法,Java多線程方法

本文目錄一覽：

1、java 如何實現多線程
2、java 多線程有幾種實現方法
3、java多線程有哪些方法
4、在Java 中多線程的實現方法有哪些，如何使用
5、java中實現多線程的方法有幾種以及如何實現多線程

java 如何實現多線程

java中多線程的實現方式有兩種，一種是繼承java.lang.Thread類，另一種是實現java.lang.Runnable接口。下面是兩種方式的簡單代碼。繼承Thread類方式：import java.lang.Thread; //用集成Thread類方式實現多線程。 public class Test{ public static void main(String arg[]){ T t1=new T(); T t2=new T(); //更改新線程名稱 t1.setName(“t1”); t2.setName(“t2″); //啟動線程 t1.start(); t2.start(); } } class T extends Thread{ //重寫run()方法 public void run(){ System.out.println(this.getName()); } }輸出結果為：t1t2實現Runnable接口方式：在使用Runnable接口時需要建立一個Thread實例。因此，無論是通過Thread類還是Runnable接口建立線程，都必須建立Thread類或它的子類的實例。import java.lang.*; //用實現Runnable接口的方式實現多線程。 public class Test{ public static void main(String arg[]){ T t1=new T(); T t2=new T(); //一定要實例化Thread對象，將實現Runnable接口的對象作為參數傳入。 Thread th1=new Thread(t1,”t1″); Thread th2=new Thread(t2,”t2”); //啟動線程 th1.start(); th2.start(); } } class T implements Runnable{ //重寫run()方法 public void run(){ System.out.println(Thread.currentThread().getName()); } }輸出結果為：t1t2public void run()方法是JAVA中線程的執行體方法，所有線程的操作都是從run方法開始，有點類似於main()方法，即主線程。

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下驗證過沒問題可以直接使用。

java多線程有哪些方法

java創建線程的方式有三種

第一種是繼承Thread類實現方法run() 不可以拋異常無返回值

第二種是實現Runnable接口實現方法run() 不可以拋異常無返回值

第三種是實現CallableT接口,接口中要覆蓋的方法是 public T call() 注意:此方法可以拋異常,而前兩種不能而且此方法可以有返回值

第三種如何運行呢 Callable接口在util.concurrent包中,由線程池提交

import java.util.concurrent.*;

ExecutorService e = Executors.newFixedThreadPool(10); 參數表示最多可以運行幾個線程

e.submit(); 這個裏面參數傳實現Callable接口那個類的對象

在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：繼承Tread類；2：實現Runable接口

1、

public class MyThread extends Thread{

//重寫run()方法

public void run(){

//多線程要做的事

}

public static void main(String args[]){

MyThread m1 = new MyThread();

MyThread m2 = new MyThread();

m1.start();

m2.start();

}

2、

public class NThread implements Runable{

//實現run()方法

public void run(){

//多線程要做的事

}

public static void main(String args[]){

NThread nt = new NThread();

new Thread(nt,”nt1_name”).start();

new Thread(nt,”nt2_name”).start();

}

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

java多線程高級用法,Java多線程方法

本文目錄一覽：

java 如何實現多線程

java 多線程有幾種實現方法

java多線程有哪些方法

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

java中實現多線程的方法有幾種以及如何實現多線程

相關推薦

發表回復