運用java線程,java 線程使用

本文目錄一覽：

• 1、Java線程怎樣使用？
• 2、如何創建並運行Java線程
• 3、在Java 中多線程的實現方法有哪些，如何使用

Java線程怎樣使用？

多進程是指操作系統能同時運行多個任務（程序），多線程是指在同一程序中有多個順序流在執行。

在java中創建一個線程有兩種方法：　

package com.thread;

public class ThreadTest1 {

    public static void main(String[] args) {

        Runnable1 r = new Runnable1();

        //r.run();並不是線程開啟，而是簡單的方法調用

        Thread t = new Thread(r);//創建線程

        //t.run(); //如果該線程是使用獨立的 Runnable 運行對象構造的，則調用該 Runnable 對象的 run 方法；否則，該方法不執行任何操作並返回。

        t.start(); //線程開啟

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

            System.out.println(“main:”+i);

        }

    }

}

class Runnable1 implements Runnable{

    public void run() {

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

            System.out.println(“Thread—–:”+i);

        }

    }

}

如何創建並運行Java線程

Java線程類也是一個object類,它的實例都繼承自java.lang.Thread或其子類。 可以用如下方式用java中創建一個線程：

Tread thread = new Thread();

執行該線程可以調用該線程的start()方法:

thread.start();

在上面的例子中，我們並沒有為線程編寫運行代碼，因此調用該方法後線程就終止了。

編寫線程運行時執行的代碼有兩種方式：一種是創建Thread子類的一個實例並重寫run方法，第二種是創建類的時候實現Runnable接口。接下來我們會具體講解這兩種方法：

創建Thread的子類

創建Thread子類的一個實例並重寫run方法，run方法會在調用start()方法之後被執行。例子如下：

public class MyThread extends Thread {

public void run(){

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

}

}

可以用如下方式創建並運行上述Thread子類

MyThread myThread = new MyThread();

myTread.start();

一旦線程啟動後start方法就會立即返回，而不會等待到run方法執行完畢才返回。就好像run方法是在另外一個cpu上執行一樣。當run方法執行後，將會打印出字符串MyThread running。

你也可以如下創建一個Thread的匿名子類：

Thread thread = new Thread(){

public void run(){

System.out.println(“Thread Running”);

}

};

thread.start();

當新的線程的run方法執行以後，計算機將會打印出字符串”Thread Running”。

實現Runnable接口

第二種編寫線程執行代碼的方式是新建一個實現了java.lang.Runnable接口的類的實例，實例中的方法可以被線程調用。下面給出例子：

public class MyRunnable implements Runnable {

public void run(){

System.out.println(“MyRunnable running”);

}

}

為了使線程能夠執行run()方法，需要在Thread類的構造函數中傳入 MyRunnable的實例對象。示例如下：

Thread thread = new Thread(new MyRunnable());

thread.start();

當線程運行時，它將會調用實現了Runnable接口的run方法。上例中將會打印出”MyRunnable running”。

同樣，也可以創建一個實現了Runnable接口的匿名類，如下所示：

Runnable myRunnable = new Runnable(){

public void run(){

System.out.println(“Runnable running”);

}

}

Thread thread = new Thread(myRunnable);

thread.start();

創建子類還是實現Runnable接口？

對於這兩種方式哪種好並沒有一個確定的答案，它們都能滿足要求。就我個人意見，我更傾向於實現Runnable接口這種方法。因為線程池可以有效的管理實現了Runnable接口的線程，如果線程池滿了，新的線程就會排隊等候執行，直到線程池空閑出來為止。而如果線程是通過實現Thread子類實現的，這將會複雜一些。

有時我們要同時融合實現Runnable接口和Thread子類兩種方式。例如，實現了Thread子類的實例可以執行多個實現了Runnable接口的線程。一個典型的應用就是線程池。

常見錯誤：調用run()方法而非start()方法

創建並運行一個線程所犯的常見錯誤是調用線程的run()方法而非start()方法，如下所示：

Thread newThread = new Thread(MyRunnable());

newThread.run(); //should be start();

起初你並不會感覺到有什麼不妥，因為run()方法的確如你所願的被調用了。但是，事實上,run()方法並非是由剛創建的新線程所執行的，而是被創建新線程的當前線程所執行了。也就是被執行上面兩行代碼的線程所執行的。想要讓創建的新線程執行run()方法，必須調用新線程的start方法。

線程名

當創建一個線程的時候，可以給線程起一個名字。它有助於我們區分不同的線程。例如：如果有多個線程寫入System.out，我們就能夠通過線程名容易的找出是哪個線程正在輸出。例子如下：

MyRunnable runnable = new MyRunnable();

Thread thread = new Thread(runnable, “New Thread”);

thread.start();

System.out.println(thread.getName());

需要注意的是，因為MyRunnable並非Thread的子類，所以MyRunnable類並沒有getName()方法。可以通過以下方式得到當前線程的引用：

Thread.currentThread();

因此，通過如下代碼可以得到當前線程的名字：

String threadName = Thread.currentThread().getName();

線程代碼舉例：

這裡是一個小小的例子。首先輸出執行main()方法線程名字。這個線程JVM分配的。然後開啟10個線程，命名為1~10。每個線程輸出自己的名字後就退出。

public class ThreadExample {

public static void main(String[] args){

System.out.println(Thread.currentThread().getName());

for(int i=0; i10; i++){

new Thread(“” + i){

public void run(){

System.out.println(“Thread: ” + getName() + “running”);

}

}.start();

}

}

}

需要注意的是，儘管啟動線程的順序是有序的，但是執行的順序並非是有序的。也就是說，1號線程並不一定是第一個將自己名字輸出到控制台的線程。這是因為線程是並行執行而非順序的。Jvm和操作系統一起決定了線程的執行順序，他和線程的啟動順序並非一定是一致的。

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

6         FutureTaskInteger ft = new FutureTaskInteger(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 CallableInteger {

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 FutureTaskV implements RunnableFutureV {

2  

3     //….

4  

5 }

1 public interface RunnableFutureV extends Runnable, FutureV {

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

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

請點右下角“採納答案”。