在Java中，如何度量进程执行的代码的执行时间？

我在做一个在线评委项目，比如HackerRank，Codeforces等等

我有线程池，当请求到来时，web服务从线程池获得一个线程，该线程使用ProcessBuilder编译代码（在此之前一切正常），在编译之后，该线程通过再次使用新的ProcessBuilder开始执行部分。但是我的“时间限制超出”部分计算不正确。当请求数量增加时，我认为该过程工作缓慢，因此任何基本代码都会超时。如何度量由进程执行的代码的执行时间？（度量不应受请求数的影响）

编辑：我的进程应该等待进程的用户时间。但我不知道怎么做

我的执行代码如下：

    package org.anil.CodeChecker.process;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.concurrent.TimeUnit;

import org.anil.CodeChecker.model.ExecutorModel;

public class Executor {
    private ProcessBuilder p;
    private String path;
    private String input;
    private String output;
    private String lang;
    private long timeInMillis;

    public Executor(String path,String input, String output,String lang,long timeInMillis ){
        this.path = path;
        this.input = input;
        this.output = output;
        this.lang = lang;
        this.timeInMillis = timeInMillis;

    }


    public ExecutorModel execute(){
        ExecutorModel model = new ExecutorModel();

        System.out.println("Code started executing");

        if(lang.equals("java")){
            p = new ProcessBuilder("java","Solution");
        }
        else if(lang.equals("c")){
            p = new ProcessBuilder("./a.out");
        }
        else if(lang.equals("c++")){
            p = new ProcessBuilder("./a.out");
        }
        else{
            System.out.println("language is not correct...");
            p = null;
        }

        p.directory(new File(path));

        p.redirectErrorStream(true);

       // System.out.println("Current directory "+System.getProperty("user.dir"));

        try{
            Process pp = p.start();

            BufferedReader reader =
                    new BufferedReader(new InputStreamReader(pp.getInputStream()));
            StringBuilder builder = new StringBuilder();
            String line = null;



            /*process e input veriliyor bu kısımda */
            OutputStream outputstream = pp.getOutputStream();
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputstream));
            writer.write(input);

            writer.flush();
            writer.close();


            if(!pp.waitFor(timeInMillis, TimeUnit.MILLISECONDS)){
                System.out.println("TİME LİMİT EXCEED !!!! ");
                model.setTimelimit(true);       
                return model;
            }

            else{
                model.setTimelimit(false);
                int exitCode = pp.exitValue();
                System.out.println("Exit Value = "+pp.exitValue());

                if(exitCode != 0){
                    System.out.println("RUNTIME ERROR !!!!!!");

                    model.setSuccess(false);
                    model.setRuntimeerror(true);
                    return model;
                }
            }



            while ( (line = reader.readLine()) != null) {
                builder.append(line);
                //builder.append(System.getProperty("line.separator"));
            }
            String result = builder.toString();
            System.out.println(" output:"+result+" input:"+input);
            if(result.charAt(result.length()-1) == ' ')
                result = result.substring(0, result.length()-1);
            if(result.equals(output)){
                model.setSuccess(true);
                model.setWronganswer(false);
                System.out.println("OUTPUT (SUCCESS) = "+result);
                return model;
            }
            else{
                model.setSuccess(false);
                model.setWronganswer(true);
                System.out.println("OUTPUTTT (FAIL) = "+result);
                return model;
            }



        }catch(IOException ioe){
            System.err.println("in execute() "+ioe);
        }catch (InterruptedException ex){
            System.err.println(ex);
        }



        System.out.println("CODE EXECUTION FINISHED !");


        return model;
    }



}

您是否尝试过：

public long getCpuTime() {
    ThreadMXBean bean = ManagementFactory.getThreadMXBean();
    return bean.isCurrentThreadCpuTimeSupported() ? bean.getCurrentThreadCpuTime() : 0L; 
}

使用该方法作为启动进程的线程启动，然后在该线程结束时再次使用该方法（因为据我所知，它也会结束进程），然后检查delta（也称为差异，方法的最后一次使用减去第一次使用），以获得该线程已运行的时间，从而间接地获得了这个过程所花费的时间

---

如果我没有误用，那么这种方法比使用例如System.currentTimeMillis（）更好，因为它计算给定给该特定线程的cpu时间，不包括其他线程以及后台运行的其他系统进程所使用的时间。

可能重复一个旁注：

lang.equals（“java”）

不安全，

“java.equals（lang）

不安全。愿原力与你同在@Sanket Makani，我读过了，我已经用过了。问题在于测量进程执行的代码的执行时间，而不是进程的执行时间如果在Unix上不直接运行子程序或Java，您可以使用标准（和传统的）

time

实用程序运行程序并报告其执行时间和可能的其他用法，在必须读取和分析的错误流上。请参阅任何sane Unix上的

人工时间

。