计算HashMap / HashTable的调用次数

Question

I have a java progam in which there are a lot of HashMap/HashTable being used for mapping key-value pairs. Now I want to profile or rather count how many times the get() and put() methods have been called in my program.

The approach which I was taking is that I extend the Java HashMap/HashTable classes and introduce a member called count and in the get() and the put() methods increment the count everytime the method gets invoked. This would involve a lot of refactoring as I would have to go and remove all the instantiations of the HashMap/HashTables to instead instantiate my extended class. Is this approach reasonable or is there other better way of maintaining this count?

Answer 1

The best solution for such a task is to use a Profiler such as YourKit or JProfiler . A profiler performs "instrumentation" on all (or a subset of) the classes loaded by the profiled JVM to perform exactly what you need: Count and measure all of the method invocations, without a single line of modified code.

Both of the aforementioned profilers ship with trial licenses. Once you have tried them, you'll probably buy one because they are very useful in so many situations.

Answer 2

You can use profiling tools which will tell you how many times a method is run and how long it takes for the code to be executed. For example, you can do this in the Eclipse IDE: http://www.eclipse.org/projects/project.php?id=tptp.performance

Answer 3

One possible way, which is more a Hack I would not recommend for production but only for profiling. The idea would be to override the java.util.HashMap class. Simply find the source code for that class, modify it with your profiling tools, then make sure it is on top of your classpath loading.

If profiling is what you need, you could use VisualVM as well to track all these calls.

Answer 4

This article should help you understand why it is best to observe performance not too close to the bottleneck itself

http://www.jinspired.com/site/case-study-scala-compiler-part-5 "Part of the problem here is that developers mistakenly believe that a performance measurement solution should direct them to the actual line of code that is the problem when generally the best starting point for both observation and tuning is just above the problem in the caller-callee chain providing an appropriate enclosing context to the execution."

That said you can always count if need be but meter it back up the caller chain:

http://www.jinspired.com/site/case-study-scalas-compiler-part-1 http://www.jinspired.com/site/case-study-scala-compiler-part-2

Answer 5

You may use inheritance : https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html

public class Main{
    public static void main(String[] args){
          HashMap<Integer,Integer> mymap = new myMap<Integer,Integer>();
          mymap.put(3,4);
          mymap.put(5,6);
          System.out.println(mymap.get(3));//this will print 4;
          System.out.println(mymap.getCountGets());//this will print 1 
          System.out.println(mymap.getCountPuts());//this will print 2
    }
}
class myMap<K,V> extends HashMap<K,V> {

public myMap(){
    countPuts = 0;
    countGets = 0;
}
private int countPuts, countGets ;

@Override
public V put(K k, V v){
    countPuts++;
    return super.put(k, v);
}
@Override
public V get(Object k){
    countGets++;
    return super.get(k);
}

public int getCountGets(){
    return countGets;
}

public int getCountPuts(){
    return countPuts;
}

}