服务时间与线程数成正比

Question

我的系统是具有超线程的i5-Dual核心。Windows向我显示4个处理器。当我一次通过单个线程运行单个优化的CPU绑定任务时，其服务时间始终显示为大约35ms。但是，当我同时将2个任务移交给2个线程时，它们的服务时间显示为大约70ms。我想问一下我的系统有4个处理器，那么如果2个线程运行teir任务时服务时间为什么会在70左右，而2个线程应该在2个处理器上运行而没有任何调度开销呢？代码如下。

CPU限制任务如下。

import java.math.BigInteger;

html" target="_blank">public class CpuBoundJob  implements Runnable {

    public void run() {

         BigInteger factValue = BigInteger.ONE;
            long t1=System.nanoTime();

            for ( int i = 2; i <= 2000; i++){
              factValue = factValue.multiply(BigInteger.valueOf(i));
            }
        long t2=System.nanoTime();

        System.out.println("Service Time(ms)="+((double)(t2-t1)/1000000));
    }

}

运行任务的线程如下。

public class TaskRunner extends Thread {
    CpuBoundJob job=new CpuBoundJob();
    public void run(){

        job.run();
    }
}

最后，主类如下。

public class Test2 {
int numberOfThreads=100;//warmup code for JIT
public Test2(){
    for(int i=1;i<=numberOfThreads;i++){//warmup code for JIT
        TaskRunner t=new TaskRunner();
        t.start();
        }
    try{
    Thread.sleep(5000);// wait a little bit
    }catch(Exception e){}
    System.out.println("Warmed up completed! now start benchmarking");
    System.out.println("First run single thread at a time");

    try{//wait for the thread to complete
        Thread.sleep(5000);
        }catch(Exception e){}
        //run only one thread at a time
            TaskRunner t1=new TaskRunner();
            t1.start();


    try{//wait for the thread to complete
        Thread.sleep(5000);
        }catch(Exception e){}

    //Now run 2 threads simultanously at a time

    System.out.println("Now run 3 thread at a time");


        for(int i=1;i<=3;i++){//run 2 thread at a time
            TaskRunner t2=new TaskRunner();
            t2.start();


            }


}
public static void main(String[] args) {
    new Test2();    
    }

最终输出：

热身完成！现在开始进行基准测试一次一次运行单线程服务时间（ms）= 5.829112现在一次运行2个线程服务时间（ms）=
6.518721服务时间（ms）= 10.364269服务时间（ms）= 10.272689

Answer 1

我在各种情况下都设置了时间，并且对任务进行了稍微修改，一个线程的时间约为45毫秒，两个线程的时间约为60毫秒。因此，即使在此示例中，一个线程也可以在一秒钟内完成大约22个任务，但是两个线程可以完成33个任务。

但是，如果您执行的任务不会给垃圾收集器带来如此巨大的负担，那么您应该会看到预期的性能提升：两个线程完成的任务数量是原来的两倍。这是我的测试程序版本。

请注意，我对您的任务（DirtyTask）进行了一项重大更改：n始终为0，因为您将结果转换Math.random()为的值int（为零），
然后 乘以13。

然后，我添加了一个CleanTask不会为垃圾收集器处理的新对象的对象。请在您的计算机上测试并报告结果。在我的身上，我得到了这个：

测试“干净”任务。
平均任务时间：一个线程= 46毫秒；两个线程= 45毫秒
测试“脏”任务。
平均任务时间：一个线程= 41毫秒；两个线程= 62毫秒



import java.util.ArrayList;
import java.util.List;
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;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

final class Parallels
{

  private static final int RUNS = 10;

  public static void main(String... argv)
    throws Exception
  {
    System.out.println("Testing \"clean\" task.");
    flavor(CleanTask::new);
    System.out.println("Testing \"dirty\" task.");
    flavor(DirtyTask::new);
  }

  private static void flavor(Supplier<Callable<Long>> tasks)
    throws InterruptedException, ExecutionException
  {
    ExecutorService warmup = Executors.newFixedThreadPool(100);
    for (int i = 0; i < 100; ++i)
      warmup.submit(tasks.get());
    warmup.shutdown();
    warmup.awaitTermination(1, TimeUnit.DAYS);
    ExecutorService workers = Executors.newFixedThreadPool(2);
    long t1 = test(1, tasks, workers);
    long t2 = test(2, tasks, workers);
    System.out.printf("Average task time: one thread = %d ms; two threads = %d ms%n", t1 / (1 * RUNS), t2 / (2 * RUNS));
    workers.shutdown();
  }

  private static long test(int n, Supplier<Callable<Long>> tasks, ExecutorService workers)
    throws InterruptedException, ExecutionException
  {
    long sum = 0;
    for (int i = 0; i < RUNS; ++i) {
      List<Callable<Long>> batch = new ArrayList<>(n);
      for (int t = 0; t < n; ++t)
        batch.add(tasks.get());
      List<Future<Long>> times = workers.invokeAll(batch);
      for (Future<Long> f : times)
        sum += f.get();
    }
    return TimeUnit.NANOSECONDS.toMillis(sum);
  }

  /**
   * Do something on the CPU without creating any garbage, and return the 
   * elapsed time.
   */
  private static class CleanTask
    implements Callable<Long>
  {
    @Override
    public Long call()
    {
      long time = System.nanoTime();
      long x = 0;
      for (int i = 0; i < 15_000_000; i++)
        x ^= ThreadLocalRandom.current().nextLong();
      if (x == 0)
        throw new IllegalStateException();
      return System.nanoTime() - time;
    }
  }

  /**
   * Do something on the CPU that creates a lot of garbage, and return the 
   * elapsed time.
   */
  private static class DirtyTask
    implements Callable<Long>
  {
    @Override
    public Long call()
    {
      long time = System.nanoTime();
      String s = "";
      for (int i = 0; i < 10_000; i++)
        s += (int) (ThreadLocalRandom.current().nextDouble() * 13);
      if (s.length() == 10_000)
        throw new IllegalStateException();
      return System.nanoTime() - time;
    }
  }

}