如何在Java中的Y線程上運行X任務？

Question

我想確定在執行100個任務的5個線程上執行任務的平均時間。

對於時間meassuring目的，我使用nanoTime()

任務是調用一個具體的方法，我們稱之爲foo(); 我不會創建任何其他類。

在我的代碼我創建了一個任務：

Runnable thExecute = new Runnable(){ 
    @Override 
    public void run(){ 
    foo(); 
    } 
}; 

然後我創建一個線程：

Thread th = new Thread(thExecute); 
long start = System.nanoTime(); 
th.run(); 
long stop = System.nanoTime(); 

這將是巨大的，如果我有相同數量的任務的線程。 我試圖創建線程和任務的數組：

Runnable[] thExecutes = new Runnable[100]; 
Thread[] ths = new Thread[5]; 

但現在我不知道下一步該怎麼做。我知道他們應該排隊，可能我應該使用Executor課程。我使用Java 6.編輯： 起初我並不是指我寫的東西。現在我知道我想要平均時間+最高時間。

Answer 1

首先要注意的是：如果你自己測量性能，你不應該期待精確的結果。有tools爲你做，提供更可靠的結果。

如果你想自己做，用的ExecutorService：

ExecutorService service = Executors.newFixedThreadPool(5); 
long startTs = System.nanoTime(); 

List<Future> futures = new ArrayList<>(); 
for (Runnable r : runnables) { 
    futures.add(service.submit(r)); 
} 
for (Future f : futures) { 
    f.get(); 
} 

long durationNs = System.nanoTime() - startTs; 

並再次：因爲你是衡量納秒，我強烈建議您避免手工測量，因爲有許多因素會破壞結果：沒有熱身，安裝費用等

更新：衡量每個任務的執行時間，你可以提交的Callable<Long>代替Runnable

public long call() { 
    long startTs = System.nanoTime(); 
    // do the task 
    return System.nanoTime() - startTs; 
} 

現在和未來將返回執行時間，你可以打印或聚集在一個列表：

for (Future<Long> f : futures) { 
    long spentTime = f.get(); 
} 

Answer 2

您可以使用Executor：

ExecutorService executorService = Executors.newFixedThreadPool(5); 
long start = System.nanoTime(); 
for (int i = 0; i < 100; i++) { 
    executorService.submit(new Runnable() { 

     @Override 
     public void run() { 
      foo(); 
     } 
    }); 
} 
try { 
    // set whatever timeout value you want (must be > than the execution time) 
    executorService.awaitTermination(1, TimeUnit.MINUTES); 
} catch (InterruptedException e) { 
    e.printStackTrace(); 
} 
long stop = System.nanoTime(); 

這將創建一個執行者有5個線程的固定大小，然後推100任務執行德。執行程序將在每個線程上分派任務。

Answer 3

我總是喜歡用ThreadPoolExecutor

ThreadPoolExecutor會更有效，如果你已經定製許多或以下所有參數優選爲：BlockingQueu e Size（控制無限隊列大小），ThreadFactory自定義線程生命週期管理& RejectedExecutionHandler來處理被拒絕的任務。

ThreadPoolExecutor(int corePoolSize, 
       int maximumPoolSize, 
       long keepAliveTime, 
       TimeUnit unit, 
       BlockingQueue<Runnable> workQueue, 
       ThreadFactory threadFactory, 
       RejectedExecutionHandler handler) 

示例代碼：

import java.util.concurrent.*; 

import java.util.concurrent.ThreadPoolExecutor.DiscardPolicy; 

class SimpleThreadFactory implements ThreadFactory { 
    String name; 
    static int threadNo = 0; 

    public SimpleThreadFactory (String name){ 
     this.name = name; 
    } 
    public Thread newThread(Runnable r) { 
    ++threadNo; 
    System.out.println("thread no:"+threadNo); 
    return new Thread(r,name+":"+threadNo); 
    } 
    public static void main(String args[]){ 
     SimpleThreadFactory factory = new SimpleThreadFactory("Factory Thread"); 
     final ThreadPoolExecutor executor = new ThreadPoolExecutor(5,20,10,TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(10),factory,new ThreadPoolExecutor.DiscardPolicy()); 
     for (int i=0; i < 1000; i++){ 
      executor.submit(new Runnable(){ 
       public void run(){ 
        // Add t1 here 
        System.out.println("Thread Name in Runnable:"+Thread.currentThread().getName()+ " of "+ executor.getPoolSize()); 
        // print System.currentTimeMillies - t1 here 
       } 
      }); 
     } 
     executor.shutdown(); 
    } 
} 

Answer 4

您的代碼根本不會因爲這樣一個單獨的線程運行

th.run(); 

你應該叫start()而不是run()實現多線程功能