探查器如何分析在java、eclipse和junit中哪个方法消耗的时间更多？

Question

对于一些专业java程序员来说，这可能是一个愚蠢的问题，但我现在快发疯了，所以我还在问。请有人给我指引正确的方向

如何分析java程序中哪种方法/方法的哪一部分花费了更多的时间

（我正在使用Eclipse和Junit）

Answer 1

使用jvisualvm。如今，它与JDK捆绑在一起，但也有一个独立的版本，这是最新的。 通常，当您启动它时，您可以选择连接到哪个正在运行的java进程（这很可能是我们正在运行的单元测试）。您可以指定需要跟踪的限定类名筛选器。通常，会出现一些类插装，您将能够跟踪分配给每个方法的处理时间（以及累计时间）

Answer 2

你需要得到一个Java profilerSome of them integrate well in Eclipse

除此之外，您还可以使用定制的profiler类（如果您没有很多评测工作要做，并且您已经怀疑存在一些瓶颈）

下面是一个简单的类：

/**
 * Small helper class to profile the code, take timing, ...
 * 
 * To use this, simply call the start method with an identifier. When you want to measure the time, call the stop method
 * with the same identifier. To output statistics, simply call the toString method or the toCsv method to create a CSV
 * file with the profiler information.
 * 
 * @author Vincent Prat @ MarvinLabs
 */
public class Profiler {

    private static final int THEORETICAL_MAX_NAME_LENGTH = 50;

    private static Profiler singletonInstance = null;

    private Map<String, Profile> profiles; // Fast access to profiles by name
    private List<Profile> profilesStack; // Profiles as created chronologically

    /**
     * Get access to the singleton instance (create it if necessary)
     */
    public static Profiler getInstance() {
        if (singletonInstance == null) {
            singletonInstance = new Profiler();
        }
        return singletonInstance;
    }

    /**
     * Protected constructor for singleton
     */
    protected Profiler() {
        profiles = new HashMap<String, Profiler.Profile>();
        profilesStack = new ArrayList<Profile>();
    }

    /**
     * Start a profile. If the profile does not exist, it will be created. If it exists, a new round of measure is
     * taken.
     * 
     * @param name
     *            The name of the profile. If possible, less than Profiler.THEORETICAL_MAX_NAME_LENGTH characters
     * 
     * @see Profiler.THEORETICAL_MAX_NAME_LENGTH
     */
    public void start(String name) {
        Profile p = profiles.get(name);
        if (p == null) {
            p = new Profile(name);
            profiles.put(name, p);
            profilesStack.add(p);
        }
        p.start();
    }

    /**
     * Stop a profile and compute some statistics about it.
     * 
     * @param name
     *            The name of the profile as declared in the corresponding start method
     */
    public void stop(String name) {
        Profile p = profiles.get(name);
        if (p == null) {
            throw new RuntimeException("The profile " + name + " has not been created by a call to the start() method!");
        }
        p.stop();
    }

    /**
     * Clear all the current measures. Not to be called within any start/stop pair.
     */
    public void reset() {
        profiles.clear();
    }

    /**
     * Build a string containing all the information about the measures we have taken so far.
     */
    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer();
        for (Profile p : profilesStack) {
            sb.append(p.toString());
            sb.append("\n");
        }
        return sb.toString();
    }

    /**
     * Output the measures to an output string
     */
    public void toCsvFile(OutputStream os) throws IOException {
        Profile.writeCsvHeader(os);
        for (Profile p : profilesStack) {
            p.writeCsvLine(os);
        }
    }

    /**
     * Profile information. It stores statistics per named profile.
     * 
     * @author Vincent Prat @ MarvinLabs
     */
    private static class Profile {
        private static final String CSV_HEADERS = "Name, Call Count, Total Time (ms), Average Time (ms), Min Time (ms), Max Time (ms), Delta Time (ms), Delta Ratio (%)\n";

        private static final String FORMAT_STRING = "%-" + THEORETICAL_MAX_NAME_LENGTH + "."
                + THEORETICAL_MAX_NAME_LENGTH
                + "s: %3d calls, total %5d ms, avg %5d ms, min %5d ms, max %5d ms, delta %5d ms (%d%%)";

        private static final String CSV_FORMAT_STRING = "%s,%d,%d,%d,%d,%d,%d,%d\n";

        private String name;
        private long startTime;
        private long callCount;
        private long totalTime;
        private long minTime;
        private long maxTime;

        public Profile(String name) {
            this.name = name;
            this.callCount = 0;
            this.totalTime = 0;
            this.startTime = 0;
            this.minTime = Long.MAX_VALUE;
            this.maxTime = Long.MIN_VALUE;
        }

        public void start() {
            startTime = System.currentTimeMillis();
        }

        public void stop() {
            final long elapsed = (System.currentTimeMillis() - startTime);
            if (elapsed < minTime) minTime = elapsed;
            if (elapsed > maxTime) maxTime = elapsed;
            totalTime += elapsed;
            callCount++;
        }

        private String getFormattedStats(String format) {
            final long avgTime = callCount == 0 ? 0 : (long) totalTime / callCount;
            final long delta = maxTime - minTime;
            final double deltaRatio = avgTime == 0 ? 0 : 100.0 * ((double) 0.5 * delta / (double) avgTime);

            return String
                    .format(format, name, callCount, totalTime, avgTime, minTime, maxTime, delta, (int) deltaRatio);
        }

        @Override
        public String toString() {
            return getFormattedStats(FORMAT_STRING);
        }

        public static void writeCsvHeader(OutputStream os) throws IOException {
            os.write(CSV_HEADERS.getBytes());
        }

        public void writeCsvLine(OutputStream os) throws IOException {
            os.write(getFormattedStats(CSV_FORMAT_STRING).getBytes());
        }
    }
}

和示例用法：

Profiler.getInstance().start("marker1");
// Do something...

Profiler.getInstance().start("marker2");

// Something else...

Profiler.getInstance().stop("marker2");

// And some more...

Profiler.getInstance().stop("marker1");

// Output the profiling result
System.out.println(Profiler.getInstance().toString());

Answer 3

说我过时，但我认为这是最简单的方法：

long a, b, c, d;
a = System.currentTimeMillis();
// some code 1
b = System.currentTimeMillis();
// some code 2
c = System.currentTimeMillis();
// some code 3
d = System.currentTimeMillis();

System.out.println("Some code 1 took "+(b-a)+"mil to execute. ("+((b-a)/1000)+" seconds)");
System.out.println("Some code 2 took "+(c-b)+"mil to execute. ("+((c-b)/1000)+" seconds)");
System.out.println("Some code 3 took "+(d-c)+"mil to execute. ("+((d-c)/1000)+" seconds)");

希望这有帮助：）

Answer 4

有一些在线工具，如IdeOne，可以为您提供代码块执行所需的时间。试试看

Answer 5

测量编程的哪一部分需要多少运行时间的过程称为“评测”

eclipse有许多评测插件。一个is described here

Answer 6

您可以看看Yourkit（商业软件），它可以监视内存、CPU等。它有一个特殊的视图，显示在方法中花费了多少时间（例如，您可以看到40%的执行时间花费在方法xyz()）