Зачем использовать 0x61c88647

Java задняя часть Безопасность

До Java 1.4 ThreadLocals вызывали гонки между потоками. В новом дизайне каждый поток имеет свою собственную ThreadLocalMap для повышения пропускной способности, однако мы по-прежнему сталкиваемся с возможностью утечек памяти, поскольку значения в ThreadLocalMap долго выполняющихся потоков не очищаются.

В более ранних версиях Java у ThreadLocals возникали конфликты при доступе к ним нескольких потоков, что делало их почти бесполезными в многоядерных приложениях. В Java 1.4 был представлен новый дизайн, в котором дизайнеры хранят ThreadLocals непосредственно в Thread. Когда мы вызовем метод get ThreadLocal сейчас, он вернет экземпляр ThreadLocalMap в текущем потоке (внутренний класс ThreadLocal).

Когда поток завершается, он удаляет все значения в своем ThreadLocal. Это происходит в методе exit() перед сборкой мусора, если мы забудем вызвать метод remove() после использования ThreadLocal, значение все еще будет существовать после выхода из потока.

ThreadLocalMap содержит слабые ссылки на ThreadLocal и сильные ссылки на значения, однако не определяет, какие значения слабых ссылок в ReferenceQueue были очищены, т.к. Entry нельзя сразу очистить от ThreadLocalMap.

С точки зрения потока каждый поток содержит ссылку на экземпляр ThreadLocalMap Экземпляр ThreadLocalMap эквивалентен пространству локальных переменных потока и хранит соответствующие данные потока следующим образом:

Entry

Entry наследуется от класса WeakReference и представляет собой структуру данных, в которой хранятся личные переменные потока. Экземпляр ThreadLocal используется в качестве ссылки, что означает, что если экземпляр ThreadLocal имеет значение null, соответствующую запись можно удалить из таблицы.

class Entry extends WeakReference<ThreadLocal<?>> {
      Object value;
      Entry(ThreadLocal<?> k, Object v) {
           super(k);
           value = v;
      }
}

ThreadLocalMap

Внутренне используйте массив таблиц для хранения записи, размер по умолчанию INITIAL_CAPACITY (16), сначала введите несколько параметров:

size: количество элементов в таблице.
threshold: 2/3 размера таблицы, когда размер >= порога, пройти по таблице и удалить элемент, ключ которого равен нулю,
Если размер >= порог*3/4 после удаления, таблицу необходимо расширить.

Реализация ThreadLocal.set()

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

Как видно из приведенного выше кода:

Получите экземпляр ThreadLocalMap из текущего потока Thread.
Экземпляр и значение ThreadLocal инкапсулируются в Entry.
Далее давайте посмотрим, как Entry хранится в массиве таблиц:

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

    for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
        if (k == key) {
            e.value = value;
            return;
        }
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

1. Сгенерируйте хэш-значение с помощью метода nextHashCode класса ThreadLocal.

private static AtomicInteger nextHashCode = new AtomicInteger();
private static int nextHashCode() {    
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

Как видно из метода nextHashCode, каждый раз, когда создается экземпляр ThreadLocal, его хэш-значение атомарно увеличивается HASH_INCREMENT.

2. Найдите позицию i в таблице с помощью хэша & (len -1), предполагая, что элемент в позиции i в таблице равен f.
3. Если f != null, предполагается, что ссылка в f равна k:

  • Если k соответствует текущему экземпляру ThreadLocal, измените значение и верните значение.
  • Если k равно null, это означает, что этот f уже является устаревшим (устаревшим) элементом. Вызовите метод replaceStaleEntry, чтобы удалить все устаревшие элементы в таблице (то есть ссылка на запись имеет значение null), вставить новые элементы и вернуться.
  • В противном случае найдите следующий элемент f с помощью метода nextIndex и перейдите к шагу 3. Если f == null, добавьте запись в позицию i таблицы. Удаляйте устаревшие элементы через cleanSomeSlots.Если в таблице не удаляются элементы, нужно определить, следует ли расширять текущую ситуацию.

4. Если f == null, добавьте запись в позицию i таблицы.
5. Удаляйте устаревшие элементы через cleanSomeSlots.Если в таблице нет элемента для удаления, необходимо решить, следует ли расширять емкость в текущей ситуации.

расширение таблицы

Если количество элементов в таблице достигает 3/4 порогового значения, будет выполнена операция расширения, процесс очень прост:

private void resize() {
    //旧数组
    Entry[] oldTab = table;
    
    //旧数组长度
    int oldLen = oldTab.length;
    //新数组长度 = 旧数组长度*2
    int newLen = oldLen * 2;
    //新数组
    Entry[] newTab = new Entry[newLen];
    //计数
    int count = 0;

    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal<?> k = e.get();
            
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }

    setThreshold(newLen);
    size = count;
    table = newTab;
}

1. Создайте новый массив newTab, размер которого вдвое превышает исходный размер.
2. Скопировать элементы таблицы в newTab, игнорируя старые элементы, предполагая, что элемент e в таблице нужно скопировать в i-ю позицию newTab, если в i-й позиции есть элемент, найти следующий пустой положение для вставки.

Реализация ThreadLocal.get()

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else
        return getEntryAfterMiss(key, i, e);
}

Получить threadLocals текущего потока.

Если threadLocals не null, соответствующая запись находится через метод ThreadLocalMap.getEntry.Если ее ссылка согласуется с текущим ключом, она будет возвращена напрямую, в противном случае она продолжит совпадать в остальных элементах таблицы.
Если threadLocals имеет значение null, он инициализируется методом setInitialValue и возвращается.

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;
    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

Магическое число 0x61c88647

  • Сгенерированный пробел хэш-кода — это магическое число, которое может сделать сгенерированное значение или идентификатор ThreadLocal более равномерно распределенным в массиве степени двойки.
private static final int HASH_INCREMENT = 0x61c88647;

private static int nextHashCode() {
   return nextHashCode.getAndAdd(HASH_INCREMENT);
}
  • Видно, что он добавляет магическое число 0x61c88647 к ID/threadLocalHashCode последнего созданного ThreadLocal.
  • Выбор этого магического числа связан с хешированием Фибоначчи, а десятичное число, соответствующее 0x61c88647, равно 1640531527.
  • Множитель хэша Фибоначчи можно использовать (long) ((1L
  • Согласно теории и практике, когда мы используем 0x61c88647 в качестве магического числа для накопления и присвоения каждому ThreadLocal собственного идентификатора, то есть threadLocalHashCode, а затем по модулю степени 2, результаты распределяются равномерно.
  • ThreadLocalMap использует метод линейного обнаружения.Преимущество равномерного распределения заключается в том, что следующий доступный слот может быть обнаружен быстро, что обеспечивает эффективность. . Для оптимизации эффективности.

ThreadLocal и утечки памяти

  • Причина, по которой обсуждается утечка памяти, заключается в том, что в сценарии повторного использования потоков, таких как пулы потоков, поток имеет длительный срок службы, а большие объекты не перерабатываются в течение длительного времени, что влияет на эффективность и безопасность система. Если поток не будет использоваться повторно, он будет уничтожен, когда будет использован, и не будет утечки памяти, вызванной ThreadLocal.

  • Когда мы внимательно читаем исходный код ThreadLocalMap, мы можем сделать вывод, что если явное удаление в процессе использования ThreadLocal является хорошей практикой кодирования, это не приведет к утечке памяти.

  • Если вы должны использовать ThreadLocal, обязательно удалите значение, как только вы закончите с ним, и желательно до возврата потока в пул потоков. Лучшей практикой является использование remove() вместо set(null), так как это приведет к немедленному удалению WeakReference вместе со значением.

Категории