我最近正在学习Java并发编程。我知道final关键字可以保证安全发布。但是，当我阅读LinkedBlockingQueue源代码时，我发现head和last字段没有使用final关键字。 我发现enqueue方法在put方法中调用，enqueue方法直接将值分配给last.next。此时，last可能是null，因为last未声明final。我的理解正确吗？虽然lock可以保证last读写线程安全，但lock可以保证last是正确的初始值而不是null
public class LinkedBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
transient Node<E> head;
private transient Node<E> last;
public LinkedBlockingQueue(int capacity) {
if (capacity <= 0) throw new IllegalArgumentException();
this.capacity = capacity;
last = head = new Node<E>(null);
}
private void enqueue(Node<E> node) {
// assert putLock.isHeldByCurrentThread();
// assert last.next == null;
last = last.next = node;
}
public void put(E e) throws InterruptedException {
if (e == null) throw new NullPointerException();
// Note: convention in all put/take/etc is to preset local var
// holding count negative to indicate failure unless set.
int c = -1;
Node<E> node = new Node<E>(e);
final ReentrantLock putLock = this.putLock;
final AtomicInteger count = this.count;
putLock.lockInterruptibly();
try {
/*
* Note that count is used in wait guard even though it is
* not protected by lock. This works because count can
* only decrease at this point (all other puts are shut
* out by lock), and we (or some other waiting put) are
* signalled if it ever changes from capacity. Similarly
* for all other uses of count in other wait guards.
*/
while (count.get() == capacity) {
notFull.await();
}
enqueue(node);
c = count.getAndIncrement();
if (c + 1 < capacity)
notFull.signal();
} finally {
putLock.unlock();
}
if (c == 0)
signalNotEmpty();
}
}
根据这篇博文 https://shipilev.net/blog/2014/safe-public-construction/即使在构造函数中写入一个final属性也足以实现安全初始化(因此您的对象将始终安全地发布(。并且capacity财产被声明为final。
简而言之，我们在三种情况下发出尾随障碍：
写了最后一个字段。请注意，我们不关心实际写入的字段，我们在退出(初始值设定项(方法之前无条件地发出屏障。这意味着，如果您至少有一个最终字段写入，则最终字段语义将扩展到用构造函数编写的所有其他字段。
也许你错过了对Java连续赋值的理解
//first last is inited in the constructor
last = head = new Node<E>(null); // only the filed's value in last is null(item & next)
// enqueue
last = last.next = node;
//equals:
last.next = node;
last = last.next;
只有当你打电话给last.next否则就没有NPE。
您是正确的，last等于具有null值的node。然而，这是故意的。lock仅用于确保每个线程都可以正确执行此类中的修改。
有时使用null值是有意为之，以指示缺少值(在本例中为空队列(。因为变量是private它只能从类内部修改，所以只要编写类的人知道null的可能性，一切都很好。
我认为您混淆了不一定相关的多个不同概念。请注意，由于lastprivate因此没有发布。此外，head和last是要修改的，所以它们不能被final。
编辑
也许我误解了你的问题...
null永远不会直接分配给last。因此，唯一可能发生这种情况的地方是在构造函数中，在last被分配new Node<E>(null)之前。尽管我们可以确定构造函数在许多线程使用之前完成，但不能保证这些值的可见性。
但是，put使用lock确实保证了使用的可见性。因此，如果没有使用lock，那么last实际上可以null.