javarunnable返回值

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

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

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

㈡ java 子線程如何返回結果給主線程

可以的 你的主線程來和子線程 synchronized 一個自boolean變數(flag)
當子線程到達一定條件是將其設置成false;
而主線程run()做這樣的設置 while(flag){}
這樣主線程就會結束了~~
其實有直接關閉線程的方法 但是不建議這么做~~
防止出現死鎖.

㈢ java中線程的run()方法

兩種方法的區別
1） start：
用
start方法來啟動線程，真正實現了多線程運行，這時無需等待run方法體代碼執行完畢而直接繼續執行下面的代碼。通過調用Thread類的
start()方法來啟動一個線程，這時此線程處於就緒（可運行）狀態，並沒有運行，一旦得到cpu時間片，就開始執行run()方法，這里方法
run()稱為線程體，它包含了要執行的這個線程的內容，Run方法運行結束，此線程隨即終止。
2） run：
run()
方法只是類的一個普通方法而已，如果直接調用Run方法，程序中依然只有主線程這一個線程，其程序執行路徑還是只有一條，還是要順序執行，還是要等待
run方法體執行完畢後才可繼續執行下面的代碼，這樣就沒有達到寫線程的目的。總結：調用start方法方可啟動線程，而run方法只是thread的一
個普通方法調用，還是在主線程里執行。這兩個方法應該都比較熟悉，把需要並行處理的代碼放在run()方法中，start()方法啟動線程將自動調用
run()方法，這是由jvm的內存機制規定的。並且run()方法必須是public訪問許可權，返回值類型為void.。

兩種方式的比較 ：

實際中往往採用實現Runable介面，一方面因為java只支持單繼承，繼承了Thread類就無法再繼續繼承其它類，而且Runable介面只有一個run方法；另一方面通過結果可以看出實現Runable介面才是真正的多線程……

㈣ java中runnable和callable的區別

1、意義區別：

Runnable介面中的run()方法的返回值是void，它做的事情只是純粹地去執行run()方法中的代碼而已；

Callable介面中的call()方法是有返回值的，是一個泛型，和Future、FutureTask配合可以用來獲取非同步執行的結果。

2、使用方法區別：

定義runnable介面的實現類，並重寫該介面的run()方法，該run()方法的方法體同樣是該線程的線程執行體。

創建 Runnable實現類的實例，並依此實例作為Thread的target來創建Thread對象，該Thread對象才是真正的線程對象。

舉例說明：

package org.thread.demo;

class MyThread extends Thread{

private String name;

public MyThread(String name) {

super();

this.name = name;
}

public void run(){

for(int i=0;i<10;i++){

System.out.println("線程開始："+this.name+",i="+i);
}

㈤ 如何在java中獲取線程非同步執行之後的結果

java中提供了Future<V>介面和實現了Future介面的FutureTask<V> 類來將線程執行之後的結果返回（通過get()方法）。
1.Future<V>介面
Runnable介面執行任務是不返回任何值的，Runnable的run()方法的執行結果是void,而Future介面的call方法是有返回結果的，這是Runnable跟Future的區別之一，它們的另一個不同之處就是實現了Runnable介面的任務執行是調用ExecutorService的execute(Runnable task)方法，而實現了Future介面的任務是調用ExecutorService的submit(Future task)方法。調用Future的get()方法就能直接得到任務的返回值，該方法會一直阻塞直到任務的結果出來為止，我們可以調用Future的isDone()方法來判斷該任務的結果是否准備就緒。
[java] view plain
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestFuture {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executor = Executors.newCachedThreadPool();
Future result1 = executor.submit(new Callable() {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 10; i++) {
sum += i;
}
return sum;
}
});
Future result2 = executor.submit(new Callable() {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 10; i < 100; i++) {
sum += i;
}
return sum;
}
});
executor.shutdown();
System.out.println(result1.get() + result2.get());
}
}
2.FutureTask類
FutureTask實現了Future介面，將一個Callable實例作為參數傳給它，就能創建一個FutureTask實例，然後用ExecutorService的submit方法來執行這個實例。最後同樣是用get方法獲取線程執行後的結果。
[plain] view plain
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class TestFutureTask {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executor = Executors.newCachedThreadPool();
Callable task = new Callable() {
@Override
public String call() throws Exception {
return "結果";
}
};
FutureTask ft = new FutureTask(task);
executor.submit(ft);
System.out.println(ft.get());
executor.shutdown();
}
}empty

㈥ java多線程問題 跳過run方法裡面的if執行

多線程

35. 並行和並發有什麼區別？

並行是指兩個或者多個事件在同一時刻發生；而並發是指兩個或多個事件在同一時間間隔發生。

並行是在不同實體上的多個事件，並發是在同一實體上的多個事件。

在一台處理器上「同時」處理多個任務，在多台處理器上同時處理多個任務。如hadoop分布式集群。

所以並發編程的目標是充分的利用處理器的每一個核，以達到最高的處理性能。

36. 線程和進程的區別？

簡而言之，進程是程序運行和資源分配的基本單位，一個程序至少有一個進程，一個進程至少有一個線程。進程在執行過程中擁有獨立的握脊內存單元，而多個線程共享內存資源，減少切換次數，從而效率更高。線程是進程的一個實體，是cpu調度和分派的基本單位，是比程序更小的能獨立運行的基本單位。同一進程中的多個線程之間可以並發執行。

37. 守護線程是什麼？

守護線程(即daemon thread)，是個服務線程，准確地來說就是服務其他的線程。

38. 創建線程有哪幾種方式？

①. 繼承Thread類創建線程類

定義Thread類的子類，並重寫該類的run方法，該run方法的方法體就代表了線程要完成的任務。因此把run方法稱為執行體。

創建Thread子類的實例，即創建了線程對象。

調用線程對象的start方法來啟動該線程。

②. 通過Runnable介面創建線程類

定義runnable介面的實現類，並重寫該介面的run方法，該run方法的方法體同樣是該線程的線程執行體。

創建 Runnable實現類的實例，並依此實例作為Thread的target來創建Thread對象，該Thread對象才是真正的線程對象。

調用線程對象的start方法來啟動該線程。

③. 通過Callable和Future創建線程

創建Callable介面的實現類，並實現call方法，該call方法將作為線程執行體，並且有返回值。

創建Callable實現類的實例，使用FutureTask類來包裝Callable對象，該FutureTask對象封裝了該Callable對象的call方法的返回值。

使用FutureTask對象作為Thread對象的target創建並啟動新線程。

調用FutureTask對象的get方法來獲得子線程執行結束後的返回值。

39. 說一下 runnable 和 callable 有什麼區別？

有點深的問題了，也看出一個Java程序員學習知識的廣度。

Runnable介面中的run方法的返回值是void，它做的事情只是純粹地去執行run方法中的代碼而已；

Callable介面中的call方法是有返回值的，是一個泛型，和Future、FutureTask配合可以用來獲取非同步執行的結果。

40. 線程有哪些狀態？

線程通常都有五種狀態，創建、就緒、運行、阻塞和死亡。

創建狀態。在生成線程對象，並沒有調用該對象的start方法，這是線程處於創建狀態。

就緒狀態。當調用了線程對象的start方法之後，該線段侍滲程就進入了就緒狀態，但是此時線程調度程序還沒有把該線程設置為當前線程，此時處於就緒狀態。在談冊線程運行之後，從等待或者睡眠中回來之後，也會處於就緒狀態。

運行狀態。線程調度程序將處於就緒狀態的線程設置為當前線程，此時線程就進入了運行狀態，開始運行run函數當中的代碼。

阻塞狀態。線程正在運行的時候，被暫停，通常是為了等待某個時間的發生(比如說某項資源就緒)之後再繼續運行。sleep,suspend，wait等方法都可以導致線程阻塞。

死亡狀態。如果一個線程的run方法執行結束或者調用stop方法後，該線程就會死亡。對於已經死亡的線程，無法再使用start方法令其進入就緒

41. sleep 和 wait 有什麼區別？

sleep：方法是線程類(Thread)的靜態方法，讓調用線程進入睡眠狀態，讓出執行機會給其他線程，等到休眠時間結束後，線程進入就緒狀態和其他線程一起競爭cpu的執行時間。因為sleep 是static靜態的方法，他不能改變對象的機鎖，當一個synchronized塊中調用了sleep 方法，線程雖然進入休眠，但是對象的機鎖沒有被釋放，其他線程依然無法訪問這個對象。

wait：wait是Object類的方法，當一個線程執行到wait方法時，它就進入到一個和該對象相關的等待池，同時釋放對象的機鎖，使得其他線程能夠訪問，可以通過notify，notifyAll方法來喚醒等待的線程

42. notify和 notifyAll有什麼區別？

如果線程調用了對象的 wait方法，那麼線程便會處於該對象的等待池中，等待池中的線程不會去競爭該對象的鎖。

當有線程調用了對象的 notifyAll方法(喚醒所有 wait 線程)或 notify方法(只隨機喚醒一個 wait 線程)，被喚醒的的線程便會進入該對象的鎖池中，鎖池中的線程會去競爭該對象鎖。也就是說，調用了notify後只要一個線程會由等待池進入鎖池，而notifyAll會將該對象等待池內的所有線程移動到鎖池中，等待鎖競爭。

優先順序高的線程競爭到對象鎖的概率大，假若某線程沒有競爭到該對象鎖，它還會留在鎖池中，唯有線程再次調用 wait方法，它才會重新回到等待池中。而競爭到對象鎖的線程則繼續往下執行，直到執行完了 synchronized 代碼塊，它會釋放掉該對象鎖，這時鎖池中的線程會繼續競爭該對象鎖。

43. 線程的 run和 start有什麼區別？

每個線程都是通過某個特定Thread對象所對應的方法run來完成其操作的，方法run稱為線程體。通過調用Thread類的start方法來啟動一個線程。

start方法來啟動一個線程，真正實現了多線程運行。這時無需等待run方法體代碼執行完畢，可以直接繼續執行下面的代碼；這時此線程是處於就緒狀態， 並沒有運行。然後通過此Thread類調用方法run來完成其運行狀態， 這里方法run稱為線程體，它包含了要執行的這個線程的內容， Run方法運行結束， 此線程終止。然後CPU再調度其它線程。

run方法是在本線程里的，只是線程里的一個函數,而不是多線程的。 如果直接調用run,其實就相當於是調用了一個普通函數而已，直接待用run方法必須等待run方法執行完畢才能執行下面的代碼，所以執行路徑還是只有一條，根本就沒有線程的特徵，所以在多線程執行時要使用start方法而不是run方法。

44. 創建線程池有哪幾種方式？

①. newFixedThreadPool(int nThreads)

創建一個固定長度的線程池，每當提交一個任務就創建一個線程，直到達到線程池的最大數量，這時線程規模將不再變化，當線程發生未預期的錯誤而結束時，線程池會補充一個新的線程。

②. newCachedThreadPool

創建一個可緩存的線程池，如果線程池的規模超過了處理需求，將自動回收空閑線程，而當需求增加時，則可以自動添加新線程，線程池的規模不存在任何限制。

③. newSingleThreadExecutor

這是一個單線程的Executor，它創建單個工作線程來執行任務，如果這個線程異常結束，會創建一個新的來替代它；它的特點是能確保依照任務在隊列中的順序來串列執行。

④. newScheledThreadPool(int corePoolSize)

創建了一個固定長度的線程池，而且以延遲或定時的方式來執行任務，類似於Timer。

45. 線程池都有哪些狀態？

線程池有5種狀態：Running、ShutDown、Stop、Tidying、Terminated

㈦ java future函數的作用

在並發編程時，一般使用runnable，然後扔給線程池完事，這種情況下不需要線程的結果。
所以run的返回值是void類型。

如果是一個多線程協作程序，比如菲波拉切數列，1，1，2，3，5，8...使用多線程來計算。
但後者需要前者的結果，就需要用callable介面了。
callable用法和runnable一樣，信襪只不過調用的是call方法，該方法有一個泛型返回值類型，你可以任意指定。

線程是帆坦薯屬於非同步計算模型，所以你不可能直接從別的線程中得到函數返回值。
這時候，Future就出場了。Futrue可以監視目標線程調用call的情況，當你調用Future的get()方法以獲得結果時，當前線態者程就開始阻塞，直接call方法結束返回結果。