CODEWITHSUNDEEP
javaperformancecoding-style
Thomas Calc
Thomas Calc

Reputation: 3014

Setting a value only on first access -- best practice, (micro)performance?

In the below code, assume that getAndClear() will get called billions of times, i.e. assume that performance matters. It will return an array only during its first call. It must return null in all further calls. (That is, my question is about micro-optimization in some sense, and I'm aware of the fact it's bad practice, but you can also consider it as a question of "which code is nicer" or "more elegant".)

public class Boo {
   public static int[] anything = new int[] { 2,3,4 };
   private static int[] something = new int[] { 5,6,7 }; // this may be much bigger as well

   public static final int[] getAndClear() {
      int[] st = something;
      something = null;
      // ... (do something else, useful)            

      return st;
   }
}

Is the below code faster? Is it better practice?

public static int[] getAndClear() {
   int[] array = sDynamicTextIdList;
   if (array != null) {
      sDynamicTextIdList = null;
      // ... (do something else, useful)     
      return array;
   }
   // ... (do something else, useful)     

   return null;
}

A further variant could be this:

public static int[] getAndClear() {
   int[] array = sDynamicTextIdList;
   if (array != null) {
      sDynamicTextIdList = null;
   }
   // ... (do something else, useful)     
   return array;
}

I know it probably breaks down to hardware architecture level and CPU instructions (setting something to 0 vs. checking for 0), and performance-wise, it doesn't matter, but then I would like to know which is the "good practive" or more quality code. In this case, the question can be reduced to this:

private static boolean value = true;       

public static int[] getTrueOnlyOnFirstCall() {
   boolean b = value;
   value = false;
   return b;
}

If the method is called 100000 times, this means that value will be set to false 99999 times unnecessarily. The other variant (faster? nicer?) would look like this:

public static int[] getTrueOnlyOnFirstCall() {
   boolean b = value;
   if (b) { 
      value = false;
      return true;
   }
   return false;
}

Moreover, compile-time and JIT-time optimizations may also play a role here, so this question could be extended by "and what about in C++". (If my example is not applicable to C++ in this form, then feel free to subtitute the statics with member fields of a class.)

Upvotes: 0

Views: 69

Answers (1)

dashrb
dashrb

Reputation: 980

IMHO, it's not worth doing the micro-optimization. One drawback to optimization is that it relies heavily on the environment (as you mentioned JIT--the version of the JDK plays a strong role; what is faster now may be slower in the future).

Code maintainability is (in my opinion) far more important over the long haul. Implement the version which is the clearest. I like the getTrueOnlyOnFirstCall() which contains the if statement, for example.

In all of these examples, though, you would need synchronization around the getters and around the portions which modify the boolean.

Upvotes: 1

Related Questions