为什么Java方法调用在这里如此昂贵？

我有一个线程执行器实现，其中包装器的成本显示为非常昂贵。有一个包装类任务，定义如下：

 class Task {
   public Runnable r;       
   public Task(Runnable r) {          
     this.r = r;                                                                   
   }  

   public void run() {       
     r.run();      
   }     

 List<task> taskList;

而对于以下情况，则为~7000ms

 for (Task t : taskList) {        
           t.run();                                                              
 }

它不是孤立发生的，而是在执行者的代码中发生的。只是想知道是否有人对可能发生的事情有所暗示

对于此测试用例，通过的runnable如下所示：

class Tester implements Runnable {                                                 
  int i;                                                                           

  public Tester(int i) {                                                           
    this.i = i;                                                                    
  }                                                                                

  @Override                                                                        
  public void run() {                                                              
    //System.out.println(i);                                                       
    for (int j = 0; j < 1000000; j++) {                                            
      i = j;                                                                       
    }                                                                              
  }                                                                                

  public int getI() {                                                              
    return i;                                                                      
  }  

class Tester实现可运行的{
int i；
公共测试仪（int i）{
这个。i=i；
}                                                                                
@凌驾
public void run（）{
//系统输出打印LN（i）；
对于（int j=0；j<1000000；j++）{
i=j；
}                                                                              
}                                                                                
public int getI（）{
返回i；
}  

---

作为参考，可以在上找到代码。运行ThreadPoolTest以获得执行结果。现在尝试更改ThreadPool.java的第41行，看看它的神奇之处。

请考虑到，在java中进行微观管理必须使用一些技巧，因为jvm可以使用JIT编译器动态优化代码，并执行许多类似的技巧您不知道，而且看起来您的测试实际上并没有完成让JVM为您完成这项工作所需的所有事情（您必须在测试前进行预热、在衬里中转义、死代码等等）

这是一个很好的开始，阅读这个主题-

---

我还建议您使用JMH框架进行这类测试，因为在其源代码中已经有很多使用JMH框架的示例。

运行的

是做什么的？它是不可行的吗？应该有（几乎为零）你在这里发布的代码不同。其他代码中一定有一些内容。你不应该共享整个代码-你应该包含一个演示问题的最小示例。你在Runnable类中做什么？！你有多少个列表？！你是如何得到数字的？你确定实验设置正确吗？如果你提供删除链接，请复制相关部分，因为链接可能会断开。
class Tester implements Runnable {                                                 
  int i;                                                                           

  public Tester(int i) {                                                           
    this.i = i;                                                                    
  }                                                                                

  @Override                                                                        
  public void run() {                                                              
    //System.out.println(i);                                                       
    for (int j = 0; j < 1000000; j++) {                                            
      i = j;                                                                       
    }                                                                              
  }                                                                                

  public int getI() {                                                              
    return i;                                                                      
  }