Why need final def in poll() method of LinkedList in Java

Question

/**
 * Retrieves and removes the head (first element) of this list.
 *
 * @return the head of this list, or {@code null} if this list is empty
 * @since 1.5
 */
public E poll() {
    final Node<E> f = first; //why final here? <<-------- ******* --------
    return (f == null) ? null : unlinkFirst(f);
}

Hi there, I'm reading the source code of JDK 1.7. In above code snippet in LinkedList.java, I cannot understand why need 'final' in poll() method. Why not :

public E poll() {
    return (first == null) ? null : unlinkFirst(first);
}

Can you share the insight of the implementation? Thanks.

score 3 · Accepted Answer · edited May 23 '17 at 10:33

Most of the methods in LinkedList use the final declaration on local variables.

LinkedList JDK 1.7 Source

This is likely related to the concept behind Using "final" modifier whenever applicable in java.

Adding final to all things which should not change simply narrows down the possibilities that you (or the next programmer, working on your code) will misinterpret or misuse the thought process which resulted in your code. At least it should ring some bells when they now want to change your previously immutable thing.

Technically, at the cost of 6 letters, you guarantee that something you don't ever expect to change will never change.

Does your proposed code work? Yes. I don't see any scenarios where it wouldn't. It is programmatically valid.

However, the use of final throughout the code supports sanity testing, and understandably, for all the util stuff that holds pretty much all of the things we do in Java together, it'd be nice to know that everything is working as intended.

Note: If there is a security issue that I have not seen, however, I would be interested to know about that, in a separate answer.

Compass, it sounds reasonable to me. – windkiosk Dec 23 '14 at 22:53 — windkiosk, Dec 23 '14 at 22:53

score 3 · Answer 2 · answered Dec 23 '14 at 22:04

Martin Buchholz answered this on the concurrency-interest list in a related question:

We in jsr166-land consider our software important enough to make optimizations we don't recommend to regular java programmers. Copying final fields to locals generates smaller bytecode and might help the jit produce better code (and with current hotspot, still does).

Using final on locals has no performance advantage, but it does have some software engineering advantages. We tend to use it for locals with the same name as a field, e.g.

final Foo foo = this.foo;

Pretty cool. Always interesting to see how things work under the hood. — Compass, Dec 24 '14 at 07:09

score 2 · Answer 3 · answered Dec 23 '14 at 21:56

Compass answer is very reasonable, but I just want to add a further guess. I think it's a micro optimization since the access to the local variable f should, on average, be faster than access to the class field first. The final modifier is good practice but doesn't effect access latency. In this specific case the gain would likely be extremely small since you are trading two class field accesses for a single class field access and two local variable accesses.

This is not something that you should do in everyday programming, but since the collections library is used by basically every single Java program in existence these things are justifiable here.

Why need final def in poll() method of LinkedList in Java

3 Answers3