java線程實現方法

發布時間: 2022-09-21 07:47:27

1. java多線程有哪幾種實現方式

JAVA多線程實現方式主要有三種：繼承Thread類、實現Runnable介面、使用ExecutorService、Callable、Future實現有返回結果的多線程。其中前兩種方式線程執行完後都沒有返回值，只有最後一種是帶返回值的。

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

[java]view plain

{
publicvoidrun(){
System.out.println("MyThread.run()");
}
}
在合適的地方啟動線程如下：

[java]view plain

MyThreadmyThread1=newMyThread();
MyThreadmyThread2=newMyThread();
myThread1.start();
myThread2.start();

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

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

[java]view plain

{
publicvoidrun(){
System.out.println("MyThread.run()");
}
}
為了啟動MyThread，需要首先實例化一個Thread，並傳入自己的MyThread實例：

[java]view plain

MyThreadmyThread=newMyThread();
Threadthread=newThread(myThread);
thread.start();
事實上，當傳入一個Runnable target參數給Thread後，Thread的run()方法就會調用target.run()，參考JDK源代碼：

[java]view plain

publicvoidrun(){
if(target!=null){
target.run();
}
}

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

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

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

2. 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的類都是可被其它線程執行的任務。

3. java 實現線程的方法

兩種方案 1.繼承Thread類 2.實現Runnable介面

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

class MyThread2 implements Runnable{
public void run()
{
System.out.println(" implements runnable");
}
}
class Run{
public static void main( String[] args )
{
new MyThread().start();
new Thread(new MyThread2()).start();
}
}

4. 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的類都是可被其它線程執行的任務。

5. 如何在Java中實現線程

class MyJoinThread extends Thread
{
public MyJoinThread()
{
super();
}
public MyJoinThread(String name)
{
super(name);
}
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println(super.getName()+":"+i);
}
}
}
public class JoinTest
{
public static void main(String[] args)
{
MyJoinThread thread=new MyJoinThread("第1個線程");
thread.start();
for(int i=0;i<10;i++)
{
System.out.println(Thread.currentThread().getName()+":"+i);
if(i==5)
{
try
{
thread.join();
}
catch (InterruptedException e)
{
System.out.println("線程被中斷");
}
}
}
}
}

6. java多線程有幾種實現方法

java中實現多線程常用的方法有以下三種：

/**
*方法一：繼承Thread類，重寫run方法
*
*@authorqd
*
*/
{

@Override
publicvoidrun(){
super.run();
}

}

/**
*方法二：實現Runnable介面，，重寫run方法
*
*@authorqd
*
*/
{

@Override
publicvoidrun(){

}

}

/**
*方法三：實現Callable<T>介面，重寫call方法
*優點：可以傳參數，有返回值類型（參數與返回值類型一致）
*
*@authorqd
*
*/
<Integer>{

@Override
publicIntegercall()throwsException{
returnnull;
}

}

7. 在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 Callable<Integer> myCallable = new MyCallable(); // 創建MyCallable對象

6 FutureTask<Integer> ft = new FutureTask<Integer>(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 Callable<Integer> {

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 FutureTask<V> implements RunnableFuture<V> {

3 //....

5 }

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

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

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

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

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

閱讀全文

熱點內容

軟體編程培訓學院發布：2025-01-11 04:00:18 瀏覽：845

路虎攬運配置怎麼查詢發布：2025-01-11 03:42:51 瀏覽：393

仿站源碼發布：2025-01-11 03:42:05 瀏覽：39

騰訊的雲伺服器發布：2025-01-11 03:40:47 瀏覽：569

百分之十的演算法發布：2025-01-11 03:34:30 瀏覽：642

java16進制tostring 發布：2025-01-11 03:24:21 瀏覽：721

mql4c語言發布：2025-01-11 03:24:20 瀏覽：255

科爾訪問蘇聯發布：2025-01-11 03:15:47 瀏覽：331

python簡單計算器發布：2025-01-11 03:15:13 瀏覽：577

python絕對路徑發布：2025-01-11 03:10:55 瀏覽：759

java線程實現方法

與java線程實現方法相關的資訊