javafor循環多線程

① 求教：java多線程與響應式流

• 單線程比多線程更快。你的測試代碼只是用了CPU資源。因為多線程需要處理線程的開銷，開銷多了自然沒有單線程快。

• 多線程是為了更充分的利用計算機的資源。比如網路,IO,CPU...如果你在for循環里加入一個磁碟寫入操作，多線程就會比單線程快了

② 在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—for循環里啟動的線程要怎麼理解

首先類繼承Thread或者實現了Runnable介面，程序就知道這是一個線程類，每次new 一個線程類，相當於創建了一個新的線程對象，使用start是啟動一個線程，線程處於就緒狀態，而run方法屬於線程體；
如此在循環體中循環了20次，創建了20個不同的線程，每次都使用了start方法，也就是啟動了20個不同的線程；
左上角有我頭像，歡迎來學習交流；

④ 如何在for循環中使用多線程

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

public class Test {
private final static Executor executor = Executors.newCachedThreadPool();//啟用多線程
public static void main(String[] args) {

for(int i=0;i<=3;i++){
final int j=i; //關鍵是這一句代碼，將 i 轉化為 j，這樣j 還是final類型的參與線程
executor.execute(new Runnable() {
@Override
public void run() {
try{
System.out.println(j);
}catch(Exception e){

}
}
});
}

}

}

⑤ java for循環中創建線程池

1. 首先要明確線程池的意思，就是線程預先創建好放在一個池裡面，使用後不會銷毀
   

2. 要區分任務和線程池，任務可以不斷添加，但是線程池裡線程的個數是固定的，當任務數超過線程數後，後面的任務需要等待有空閑的線程才會執行

3. 所以不斷添加任務沒有關系，如果池中有50個線程，你添加100個任務同一時間也只會執行50個任務，剩下的50個任務需要等待前面的任務執行完畢後繼續執行

4. 所以你的主線程原則上可以不斷for，但是你總得有個結束點吧

⑥ JAVA多線程里的循環耗時

這里你要改變下思維方式。雖然物理上是兩個獨立事件（開槍和子彈飛），但是計算機在繪圖的時候，啟示是一幀幀畫上去的。所有的事件都是由連續幀繪制出來的。因此，只需要一個線程就可以了：

publicvoidrun(){
intt=0;
while(flag){
intbullet_time=t%600;
//fire
if(bullet_time==0){
//drawfireevent
}
else{
//drawbullets
switch(bullet_time){
case100:
//drawbullet1
break;
//drawbullet2
case200:
break;
//drawbullet3
case300:
break;
//drawbullet4
case400:
break;
//drawbullet5
case500:
break;

}
}
t+=100;
try{Thread.sleep(100);}catch(Exceptione){e.printStackTrace();}}}

⑦ Java線程池優化for循環

那麼我們要做的就是把要做的事情開多線程里去處理，可以簡單的實現如下

packagecom.wenxy.test...bank;

importjava.util.Iterator;
importjava.util.concurrent.Executor;
importjava.util.concurrent.Executors;

publicclassTestLoop{

publicstaticinti=0;

voiddoSomething(){
System.out.println(Thread.currentThread().getName()
+"isdoing。。。andi="+i);
i++;
}

publicstaticvoidmain(String[]args){

finalTestLooptestLoop=newTestLoop();

//創建一個線程池，用10個線程處理
Executorexecutor=Executors.newFixedThreadPool(10);

for(inti=0;i<100;i++){
executor.execute(newRunnable(){

@Override
publicvoidrun(){
testLoop.doSomething();
}
});
}

}

}

⑧ JAVA里怎麼讓2個FOR循環並發同時執行

不能在同一個方法內並發運行兩個for循環，因為在方法體內是順序執行的，前一個for不跳出，後一個for是不能執行的。
如果想要並發執行，需要使用Thread類，詳情可以去看關於java線程的知識。