Oggetti.requireNonNull è meno efficiente del vecchio modo?

Question

Dal JDK 7 ho felicemente con il metodo ha introdotto a respingere null valori che sono passati ad un metodo che non li possono accettare:

private void someMethod(SomeType pointer, SomeType anotherPointer) { 
    Objects.requireNonNull(pointer, "pointer cannot be null!"); 
    Objects.requireNonNull(anotherPointer, "anotherPointer cannot be null!"); 
    // Rest of method 
} 

Penso che questo metodo rende il codice molto ordinata che è facile da leggere, e sto cercando di incoraggiare i colleghi a usarlo. Ma uno (particolarmente competenti) collega è resistente, e dice che il vecchio modo è più efficiente:

private void someMethod(SomeType pointer, SomeType anotherPointer) { 
    if (pointer == null) { 
     throw new NullPointerException("pointer cannot be null!"); 
    } 
    if (anotherPointer == null) { 
     throw new NullPointerException("anotherPointer cannot be null!"); 
    } 
    // Rest of method 
} 

Dice che chiama requireNonNull prevede il posizionamento altro metodo nello stack di chiamate JVM e si tradurrà in prestazioni di peggio di un semplice == null controllo.

Quindi la mia domanda: c'è qualche prova di una sanzione di prestazioni sostenute utilizzando i metodi Objects.requireNonNull?

Answer 1

Let alla realizzazione di requireNonNull nel JDK di Oracle:

public static <T> T requireNonNull(T obj) { 
    if (obj == null) 
     throw new NullPointerException(); 
    return obj; 
} 

Ecco, questo è molto semplice . La JVM (Oracle, comunque) include un compilatore just-in-time a due stadi di ottimizzazione per convertire bytecode in codice macchina. Inline metodi banali come questo se può ottenere prestazioni migliori in questo modo.

Quindi no, non è probabile che sia più lento, non in alcun modo significativo, non ovunque sia importante.

Quindi la mia domanda: c'è qualche evidenza di una penalizzazione delle prestazioni di essere sostenute utilizzando i metodi Objects.requireNonNull?

L'unica prova che avrebbe avuto importanza sarebbe misurazioni delle prestazioni del vostro codebase, o di codice progettato per essere altamente rappresentativo di esso. È possibile testare questo con uno strumento di test delle prestazioni decente, ma a meno che il tuo collega non indichi un esempio reale di un problema di prestazioni nella tua base di codice relativa a questo metodo (piuttosto che un benchmark sintetico), tenderei ad assumere tu e lui/lei avete pesce più grande da friggere.

---

Come un po 'di parte, ho notato il tuo metodo di campionamento è un metodo private. Quindi solo il codice che il tuo team sta scrivendo lo chiama direttamente. In tali situazioni, è possibile verificare se si dispone di un caso d'uso per assertions anziché per i controlli di runtime. Le asserzioni hanno il vantaggio di non essere affatto eseguite nel codice "rilasciato" e quindi di essere più veloci di entrambe le alternative nella tua domanda. Ovviamente ci sono posti in cui sono necessari controlli di runtime, ma quelli sono di solito in punti di gatekeeping, metodi pubblici e così via. Solo FWIW.

Answer 2

Probabilmente il tuo collega ha torto.

JVM è molto intelligente e molto probabilmente incorpora il metodo Objects.requireNonNull(...). La performance è discutibile, ma ci saranno sicuramente delle ottimizzazioni molto più gravi di questa.

È necessario utilizzare il metodo di utilità da JDK. sguardo

Answer 3

Se si desidera prove ... quindi il modo per farlo è scrivere un micro-benchmark.

(Consiglio di osservare prima il progetto Calliper o JMH ... secondo la raccomandazione di Boris. In ogni caso, non provare e scrivere un micro-benchmark da zero. Ci sono troppi modi per sbagliare).

Tuttavia, si può dire al vostro collega due cose:

• Il compilatore JIT fa un buon lavoro di inlining chiamate di metodo di piccole dimensioni, ed è probabile che questo accadrà in questo caso.

• Se non fosse in linea la chiamata, è probabile che la differenza di prestazioni sarebbe solo da 3 a 5 istruzioni, ed è altamente improbabile che farebbe una differenza significativa.

Answer 4

Formalmente, vostro collega ha ragione:

• Se someMethod() o traccia corrispondente non è abbastanza caldo, il bytecode viene interpretato, e stack frame in più si crea

• Se someMethod() viene richiamato al 9 ° livello di profondità dall'hot spot, le chiamate requireNonNull() non devono essere in linea a causa di MaxInlineLevel JVM Option

• Se il metodo non è in linea per nessuno dei motivi sopra indicati, argomento di T.J. Crowder entra in gioco se si utilizza la concatenazione per produrre il messaggio di errore

• Anche se requireNonNull() è in linea, JVM spreca tempo e spazio per eseguire questa operazione.

D'altra parte, v'è FreqInlineSize opzione JVM, che vieta inlining troppo grande (in bytecode) metodi. I bytecode del metodo vengono conteggiati da soli, senza la dimensione contabile dei metodi, chiamati all'interno di questo metodo. Pertanto, l'estrazione di parti di codice in metodi indipendenti potrebbe essere utile a volte, nell'esempio con requireNonNull() questa estrazione è già stata effettuata per te.

Answer 5

Objects.requireNonNull è più ottimizzato come se si fosse riusabilità del codice. Anche in oracolo requireNonNull si definito come

public static <T> T requireNonNull(T obj) { 
    if (obj == null) 
     throw new NullPointerException(); 
    return obj; 
} 

così la sua già in bytecode.