Java 理解给定代码的代码执行路径

我是Java新手，有人能解释一下在下面给定的代码中哪个方法调用call方法吗， 还可以帮助我了解给定代码的代码执行路径：

import java.util.ArrayList;
import java.util.Date;
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;

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        Thread.sleep(1000);         
        return Thread.currentThread().getName();
    }

    public static void main(String args[]){
        //Get ExecutorService from Executors utility class, thread pool size is 10
        ExecutorService executor = Executors.newFixedThreadPool(10);            
        List<Future<String>> list = new ArrayList<Future<String>>();            
        Callable<String> callable = new MyCallable();

        for(int i=0; i< 100; i++){              
            Future<String> future = executor.submit(callable);              
            list.add(future);
        }

        for(Future<String> fut : list){
            try {               
                System.out.println(new Date()+ "::"+fut.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }           
        executor.shutdown();
    }
}

import java.util.ArrayList；
导入java.util.Date；
导入java.util.List；
导入java.util.concurrent.Callable；
导入java.util.concurrent.ExecutionException；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入java.util.concurrent.Future；
公共类MyCallable实现了Callable{
@凌驾
公共字符串调用（）引发异常{
睡眠（1000）；
返回Thread.currentThread（）.getName（）；
}
公共静态void main（字符串参数[]）{
//从Executors实用程序类获取ExecutorService，线程池大小为10
ExecutorService executor=Executors.newFixedThreadPool（10）；
列表=新的ArrayList（）；
Callable Callable=新的MyCallable（）；
对于（int i=0；i<100；i++）{
未来=执行人提交（可调用）；
增加（未来）；
}
对于（未来未来：列表）{
试试{
System.out.println（newdate（）+“：”+fut.get（））；
}捕获（中断异常|执行异常e）{
e、 printStackTrace（）；
}
}           
executor.shutdown（）；
}
}

当执行器.sumbit（可调用）时时，异步任务将与当前线程并行启动，以调用所提供的

可调用的
方法的
调用（）。“并行”在这里是指由
Executors创建的线程池的10个线程之一。newFixedThreadPool（10）

然后，您当前的线程（在
main（）
中）继续运行，这样做了一百次（如果所有10个线程都已忙，
Callable
s将排队）

要检索每个调用的结果，您必须使用
submit
s提供给您的对象，使用
get（）
。此
fut.get（）
将等待相应的
call（）
完成，并返回调用结果。
在此代码中，您使用的是执行器和线程池
executor.submit（callable）
使执行者将您的可调用放入池中的一个线程中，并通过运行
call（）
方法启动此线程。要理解此代码，您应该阅读以下三个站点：

可调用：

线程池：

执行者：
代码向包含10个线程的
ExecutorService
提交
Callable
100次，并捕获指示每个Callable何时运行的未来

ExecutorService executor = Executors.newFixedThreadPool(10);            
List<Future<String>> list = new ArrayList<Future<String>>();            
Callable<String> callable = new MyCallable();

for (int i = 0; i < 100; i++)
{              
  Future<String> future = executor.submit(callable);              
  list.add(future);
}

您是Java新手，但已经想使用
thread
s了吗？如果您先了解基础知识，并在开始高级课程之前知道如何调试应用程序，这可能是最好的。谢谢您的解释
for(Future<String> fut : list)
{
  try 
  {               
    System.out.println(new Date() + "::" + fut.get());
  } 
  catch (InterruptedException | ExecutionException e) 
  {
    e.printStackTrace();
  }
}     

executor.shutdown();