class testx
{
public testx()
{
long startTime = System.nanoTime();
System.out.println((System.nanoTime() - startTime));
}
public static void main(String args[])
{
new testx();
new testx();
new testx();
}
}
I always get results similar to this 7806 660 517
. Why the first call takes 10 times more time than other ones?
Constructors are called only once at the time of the creation of the object.
It is just stopping you from executing logic that you can't fit into a single expression. There are similar rules for calling this() . The compiler says, call to this must be first statement in constructor .
This is why the constructor of base class is called first to initialize all the inherited members.
Constructor is called about 3 times. Deconstructor is also called about 2 times. Some times in an unexpected order like Costructor, Constructor, Deconstructor, Constructor, Deconstructor.
Because the JVM loads a bunch o' classes for the first time at that point. Once that first System.nanoTime()
returns, you have already loaded System.class
and testx.class
, but once System.out.println
comes into the picture, I suspect a lot of I/O classes get loaded up, and that takes some time.
In any event, this is not a good benchmarking technique; you should really be warming up the JIT by running something for ~10000 iterations before you start measuring it. Alternately (and preferably), use a pre-built benchmarking tool like Caliper.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With