How does node.next = node; in Java AQS source code help with garbage collection?

The GC optimization effect of cancelAcquire method in Java AQS source code: node.next = node;

When we are delving into the AQS (AbstractQueuedSynchronizer) source code in Java concurrency package, we often encounter a code in the cancelAcquire method: node.next = node; // help GC. This line of code comments suggest that it helps garbage collection, but its specific mechanism of action is not clear at a glance. Many developers may wonder: Why can simple self-circulating references improve GC efficiency? And is this really necessary?

The core issue of the article is to understand how node.next = node; this line of code helps garbage collection. Although the cancelAcquire method itself is not responsible for removing canceled nodes (actual removal is done by other methods such as acquireQueued), node.next = node; this operation plays a key role in the garbage collection process.

The key to the problem lies in cross-generational references. Even if a node has been removed from the AQS queue, making it logically unreachable, if the node has been promoted to the old age, it may still hold a reference to other nodes in the young generation (via next pointer). This cross-generation reference will prevent garbage collection of young generation nodes, even if these young generation nodes themselves are already unreachable. node.next = node; effectively cuts off the node's reference to other nodes of the younger generation, avoiding this cross-generation reference problem. Without this line of code, even if the logically unreachable nodes are in the old age, their next pointer points to the young generation nodes, which will hinder the young generation garbage collection, resulting in an increase in memory fragmentation and Full GC times.

It is worth noting that pointing next pointer to itself rather than null is because next pointing to null has a special meaning in AQS - indicating the tail of the queue. Although pointing next to null in theory can also achieve the purpose of cutting off references, this will change the structure of the queue and cause potential concurrency problems.

Additionally, AQS is a bidirectional queue, and ideally it should also handle prev pointers. However, in other methods of removing cancel nodes, similar treatments are not performed on the prev pointer, which implies that although node.next = node; can effectively alleviate the problem, there are still cross-generation reference problems caused by prev pointer, but the impact range is relatively small.

Finally, the article points out that in JDK17, node.next = node; line of code has been removed from the cancelAcquire method, which indicates that the latest JDK version may have solved this problem by improving the GC algorithm (such as better handling of cross-generation references), making this line of code no longer necessary. This also indirectly confirms that the function of this line of code is mainly to deal with the shortcomings of the previous version of the JVM garbage collection mechanism.

The above is the detailed content of How does node.next = node; in Java AQS source code help with garbage collection?. For more information, please follow other related articles on the PHP Chinese website!