Diagram of circular linked list of HashMap

@author: Jingdai
@date: 2021.03.20

Reviewing the knowledge points of HashMap, I always see that there may be a circular linked list problem in multi-threaded operations before jdk1.7. I don't understand it very well, so I studied the source code and drew the picture and finally figured it out and recorded it.

Since my computer only has jdk1.5 and jdk1.8, the following analysis is based on jdk1.5, and jdk1.7 should be the same.

Where the circular linked list happens

The circular linked list occurs when multiple threads simultaneously put the HashMap to expand the HashMap. Look at the code below.

public V put(K key, V value)

public V put(K key, V value) {
    
    
	if (key == null)
	    return putForNullKey(value);
        
    int hash = hash(key.hashCode());
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
    
    
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
    
    
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

The preceding code is used to determine the insertion cycle of Entrywhether existing key, is to be replaced, this is not our concern, adding elements mainly in the second row of the inverse method addEntry. Look at this method below.

void addEntry(int hash, K key, V value, int bucketIndex)

void addEntry(int hash, K key, V value, int bucketIndex) {
    
    
	Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
    if (size++ >= threshold)
        resize(2 * table.length);
}

See the last two lines of the code. If the added element reaches the expansion threshold, perform the resize operation, pass in a new array length of twice the capacity, and continue to enter this method.

void resize(int newCapacity)

void resize(int newCapacity) {
    
    
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
    
    
        threshold = Integer.MAX_VALUE;
        return;
    }

    Entry[] newTable = new Entry[newCapacity];
    transfer(newTable);
    table = newTable;
    threshold = (int)(newCapacity * loadFactor);
}

Whether the first few lines of judgment oldCapacity code is already the largest, and the case is not expansion, see below where Entry[] newTable = new Entry[newCapacity];this line of code, when satisfied expansion conditions, creates a size for the new HashMap 2 multiples of length, and then call transfer method The old elements are passed to the new HashMap, and finally the new HashMap is passed to the table variable. The main expansion operation is in the transfer method, which is also the place where the circular linked list occurs. Let's look at it next.

void transfer(Entry[] newTable)

void transfer(Entry[] newTable) {
    
    
    Entry[] src = table;
    int newCapacity = newTable.length;
    for (int j = 0; j < src.length; j++) {
    
    
        Entry<K,V> e = src[j];
        if (e != null) {
    
    
            src[j] = null;
            do {
    
    
                Entry<K,V> next = e.next;
                int i = indexFor(e.hash, newCapacity);  
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            } while (e != null);
        }
    }
}

The code is not long, we have found the place where the circular linked list occurs, and we specifically analyze how to generate the circular linked list.

Circular linked list generation analysis

To understand how the circular linked list is generated, we first look at how the transfer method works normally in a single thread, and the following graphical analysis is used.