Penjelasan terperinci dan analisis kod sumber ThreadLocal dalam pengaturcaraan Java

Pengenalan

ThreadLocal menyediakan cara supaya dalam persekitaran berbilang benang, setiap utas boleh mempunyai data uniknya sendiri dan boleh Dilalui dari atas ke bawah sepanjang pelaksanaan benang.

1. Demonstrasi penggunaan

Ramai pelajar mungkin tidak pernah menggunakan ThreadLocal sebelum ini menjalankan keputusan, anda boleh Lihat, nilai yang sepadan dengan key1 telah diperoleh daripada konteks.

/**
 * ThreadLocal 中保存的数据是 Map
 */
static final ThreadLocal<Map<String, String>> context = new ThreadLocal<>();
@Test
public void testThread() {
  // 从上下文中拿出 Map
  Map<String, String> contextMap = context.get();
  if (CollectionUtils.isEmpty(contextMap)) {
    contextMap = Maps.newHashMap();
  }
  contextMap.put("key1", "value1");
  context.set(contextMap);
  log.info("key1，value1被放到上下文中");
	// 从上下文中拿出刚才放进去的数据
  getFromComtext();
}
private String getFromComtext() {
  String value1 = context.get().get("key1");
  log.info("从 ThreadLocal 中取出上下文，key1 对应的值为：{}", value1);
  return value1;
}
//运行结果:
demo.ninth.ThreadLocalDemo - key1，value1被放到上下文中
demo.ninth.ThreadLocalDemo - 从 ThreadLocal 中取出上下文，key1 对应的值为：value1

Kaedah getFromComtext tidak menerima sebarang parameter input Melalui baris kod ini, context.get().get(“key1”), nilai key1 diperoleh daripada konteks Seterusnya, mari ambil a lihat ThreadLocal. Bagaimana lapisan asas melaksanakan pemindahan konteks.

2. Struktur kelas

2.1. Generik kelas

ThreadLocal mentakrifkan kelas dengan generik, menunjukkan bahawa ThreadLocal boleh menyimpan data dalam mana-mana format adalah seperti berikut:

2.2. Atribut utama

public class ThreadLocal<T> {}

ThreadLocal mempunyai beberapa atribut utama Mari kita lihat satu persatu:

Terdapat satu lagi atribut penting. : ThreadLocalMap, apabila thread Apabila terdapat berbilang ThreadLocals, bekas diperlukan untuk mengurus berbilang ThreadLocals Ini ialah peranan ThreadLocalMap, untuk mengurus berbilang ThreadLocals dalam thread.

// threadLocalHashCode 表示当前 ThreadLocal 的 hashCode，用于计算当前 ThreadLocal 在 ThreadLocalMap 中的索引位置
private final int threadLocalHashCode = nextHashCode();
// 计算 ThreadLocal 的 hashCode 值(就是递增)
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// static + AtomicInteger 保证了在一台机器中每个 ThreadLocal 的 threadLocalHashCode 是唯一的
// 被 static 修饰非常关键，因为一个线程在处理业务的过程中，ThreadLocalMap 是会被 set 多个 ThreadLocal 的，多个 ThreadLocal 就依靠 threadLocalHashCode 进行区分
private static AtomicInteger nextHashCode = new AtomicInteger();

2.2.1, ThreadLocalMap

ThreadLocalMap itu sendiri ialah struktur Peta yang mudah, kuncinya ialah ThreadLocal, nilainya ialah nilai yang disimpan oleh ThreadLocal, lapisan bawah ialah struktur data tatasusunan, kod sumber adalah seperti berikut:

Daripada kod sumber, kita dapat melihat bahawa ThreadLocalMap sebenarnya adalah struktur Peta yang mudah Lapisan bawah ialah tatasusunan, dengan saiz permulaan dan saiz ambang pengembangan. Elemen tatasusunan ialah Entry Kunci Entry ialah rujukan kepada ThreadLocal, dan nilainya ialah nilai ThreadLocal.

// threadLocalHashCode 表示当前 ThreadLocal 的 hashCode，用于计算当前 ThreadLocal 在 ThreadLocalMap 中的索引位置
private final int threadLocalHashCode = nextHashCode();
// 计算 ThreadLocal 的 hashCode 值(就是递增)
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// static + AtomicInteger 保证了在一台机器中每个 ThreadLocal 的 threadLocalHashCode 是唯一的
// 被 static 修饰非常关键，因为一个线程在处理业务的过程中，ThreadLocalMap 是会被 set 多个 ThreadLocal 的，多个 ThreadLocal 就依靠 threadLocalHashCode 进行区分
private static AtomicInteger nextHashCode = new AtomicInteger();

3. Bagaimanakah ThreadLocal mencapai pengasingan data antara utas

ThreadLocal selamat untuk thread dan kami boleh menggunakannya dengan yakin, terutamanya kerana ThreadLocalMap ialah atribut bagi thread di thread Thread Kod sumber Eksklusif untuk pengasingan.

Apabila urutan induk mencipta urutan anak, ia akan menyalin nilai inheritableThreadLocals, tetapi bukan nilai threadLocals Kod sumber adalah seperti berikut:

<.>Dari atas Kita dapat melihat dalam rajah bahawa apabila thread dicipta, nilai atribut inheritableThreadLocals thread induk akan disalin.

4. Kaedah tetapkan

Fungsi utama kaedah set adalah untuk menetapkan nilai dalam ThreadLocal semasa Jika jenis generik ThreadLocal semasa ialah Map, maka ia adalah untuk menetapkan peta dalam ThreadLocal semasa Kod sumber adalah seperti berikut:

Logik kod agak jelas Mari kita lihat kod sumber ThreadLocalMap.set, seperti berikut:

Kita harus memberi perhatian kepada beberapa perkara dalam kod sumber di atas:

menggunakan AtomicInteger yang semakin meningkat sebagai Kod cincang ThreadLocal

// set 操作每个线程都是串行的，不会有线程安全的问题
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    // 当前 thradLocal 之前有设置值，直接设置，否则初始化
    if (map != null)
        map.set(this, value);
    // 初始化ThreadLocalMap
    else
        createMap(t, value);
}

Rumus untuk mengira kedudukan indeks tatasusunan ialah: kod cincang modulo saiz tatasusunan, Oleh itu,Kod cincang yang berbeza kemungkinan besar akan mengira kedudukan indeks tatasusunan yang sama (tetapi jangan risau tentang perkara ini, dalam keadaan sebenar. projek, terdapat sangat sedikit ThreadLocals, dan pada dasarnya tiada konflik); untuk mencari ke belakang melalui +1 sehingga ia menemui kedudukan indeks kosong, dan meletakkan ThreadLocal semasa sebagai kunci.

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    // 计算 key 在数组中的下标，其实就是 ThreadLocal 的 hashCode 和数组大小-1取余
    int i = key.threadLocalHashCode & (len-1);
 
    // 整体策略：查看 i 索引位置有没有值，有值的话，索引位置 + 1，直到找到没有值的位置
    // 这种解决 hash 冲突的策略，也导致了其在 get 时查找策略有所不同，体现在 getEntryAfterMiss 中
    for (Entry e = tab[i];
         e != null;
         // nextIndex 就是让在不超过数组长度的基础上，把数组的索引位置 + 1
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
        // 找到内存地址一样的 ThreadLocal，直接替换
        if (k == key) {
            e.value = value;
            return;
        }
        // 当前 key 是 null，说明 ThreadLocal 被清理了，直接替换掉
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    // 当前 i 位置是无值的，可以被当前 thradLocal 使用
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 当数组大小大于等于扩容阈值(数组大小的三分之二)时，进行扩容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

Mujurlah, apabila menggunakan ThreadLocal dalam kerja harian, kami selalunya hanya menggunakan 1~2 ThreadLocal, dan kebarangkalian tatasusunan pendua yang dikira melalui pencincangan tidak begitu tinggi.

• Strategi untuk menyelesaikan konflik kedudukan elemen tatasusunan semasa set juga mempengaruhi kaedah dapatkan.

5. kaedah get

• Kaedah get terutamanya mendapat nilai yang disimpan dalam ThreadLocal semasa daripada ThreadLocalMap Kod sumber adalah seperti berikut:

• Kemudian mari kita. lihat kaedah getEntry ThreadLocalMap, kod sumber adalah seperti berikut:

get Komen dalam kod sumber logik telah ditulis dengan sangat jelas, jadi kami tidak akan mengulanginya lagi .

6. Pengembangan kapasiti

Apabila bilangan ThreadLocals dalam ThreadLocalMap melebihi ambang, ThreadLocalMap akan mula berkembang >Anotasi kod sumber juga agak jelas Kami memberi perhatian kepada dua perkara:

Selepas pengembangan, saiz tatasusunan adalah dua kali ganda daripada tatasusunan asal

public T get() {
    // 因为 threadLocal 属于线程的属性，所以需要先把当前线程拿出来
    Thread t = Thread.currentThread();
    // 从线程中拿到 ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        // 从 map 中拿到 entry，由于 ThreadLocalMap 在 set 时的 hash 冲突的策略不同，导致拿的时候逻辑也不太一样
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 如果不为空，读取当前 ThreadLocal 中保存的值
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 否则给当前线程的 ThreadLocal 初始化，并返回初始值 null
    return setInitialValue();
}

Apabila pengembangan Tiada isu keselamatan utas sama sekali, kerana ThreadLocalMap ialah atribut bagi utas A hanya boleh beroperasi pada ThreadLocalMap pada masa yang sama Kerana pelaksanaan logik perniagaan oleh utas yang sama mestilah bersiri pengendalian ThreadLocalMap juga mestilah bersiri.

// 得到当前 thradLocal 对应的值，值的类型是由 thradLocal 的泛型决定的
// 由于 thradLocalMap set 时解决数组索引位置冲突的逻辑，导致 thradLocalMap get 时的逻辑也是对应的
// 首先尝试根据 hashcode 取模数组大小-1 = 索引位置 i 寻找，找不到的话，自旋把 i+1，直到找到索引位置不为空为止
private Entry getEntry(ThreadLocal<?> key) {
    // 计算索引位置：ThreadLocal 的 hashCode 取模数组大小-1
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    // e 不为空，并且 e 的 ThreadLocal 的内存地址和 key 相同，直接返回，否则就是没有找到，继续通过 getEntryAfterMiss 方法找
    if (e != null && e.get() == key)
        return e;
    else
    // 这个取数据的逻辑，是因为 set 时数组索引位置冲突造成的  
        return getEntryAfterMiss(key, i, e);
}

Atas ialah kandungan terperinci Penjelasan terperinci dan analisis kod sumber ThreadLocal dalam pengaturcaraan Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!