Java中ThreadLocal的用法和原理

twilight0402發表於2023-04-12
Javathread

用法

  • 隔離各個執行緒間的資料
  • 避免執行緒內每個方法都進行傳參，執行緒內的所有方法都可以直接獲取到ThreadLocal中管理的物件。
package com.example.test1.service;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;

@Component
public class AsyncTest {

    // 使用threadlocal管理
    private static final ThreadLocal<SimpleDateFormat> dateFormatLocal =
            ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));

    // 不用threadlocal進行管理，用於對比
    SimpleDateFormat dateFormat = new SimpleDateFormat();

    // 執行緒名稱以task開頭
    @Async("taskExecutor")
    public void formatDateSync(String format, Date date) throws InterruptedException {
        SimpleDateFormat simpleDateFormat = dateFormatLocal.get();
        simpleDateFormat.applyPattern(format);
        
        // 所有方法都可以直接使用這個變數，而不用根據形參傳入
        doSomething();
        
        Thread.sleep(1000);
        System.out.println("sync " + Thread.currentThread().getName() +  " | " + simpleDateFormat.format(date));
        
        // 執行緒執行完畢，清除資料
        dateFormatLocal.remove();
    }

    // 執行緒名稱以task2開頭
    @Async("taskExecutor2")
    public void formatDate(String format, Date date) throws InterruptedException {
        dateFormat.applyPattern(format);
        Thread.sleep(1000);
        System.out.println("normal " + Thread.currentThread().getName() +  " | " + dateFormat.format(date));
    }
}

使用junit進行測試：

	@Test
	void test2() throws InterruptedException {
		for(int index = 1; index <= 10; ++index){
			String format = index + "-yyyy-MM-dd";
			Date time = new Date();
			asyncTest.formatDate(format, time);
		}

		for(int index = 1; index <= 10; ++index){
			String format = index + "-yyyy-MM-dd";
			Date time = new Date();
			asyncTest.formatDateSync(format, time);
		}
	}

結果如下，可以看到沒有被 ThreadLocal 管理的變數已經無法匹配正確的format。

sync task--10 | 10-2023-04-11
sync task--9 | 9-2023-04-11
normal task2-3 | 2-2023-04-11
normal task2-5 | 2-2023-04-11
normal task2-10 | 2-2023-04-11
normal task2-6 | 2-2023-04-11
sync task--1 | 1-2023-04-11
normal task2-7 | 2-2023-04-11
normal task2-8 | 2-2023-04-11
normal task2-9 | 2-2023-04-11
sync task--6 | 6-2023-04-11
sync task--3 | 3-2023-04-11
sync task--2 | 2-2023-04-11
sync task--7 | 7-2023-04-11
sync task--4 | 4-2023-04-11
sync task--8 | 8-2023-04-11
normal task2-4 | 2-2023-04-11
normal task2-1 | 2-2023-04-11
sync task--5 | 5-2023-04-11
normal task2-2 | 2-2023-04-11

實現原理

從ThreadLocal中獲取資料的過程：

  • 先獲取對應的執行緒。
  • 透過 getMap(t)拿到執行緒中的 ThreadLocalMap
  • ThreadLocalMap 是一個重新實現的雜湊表，基於兩個元素實現雜湊：
    • 使用者定義的ThreadLocal物件，例如：dateFormatLocal。
    • 封裝了value的Entry物件。
  • 透過map.getEntry(this)方法，根據當前的 threadlocal物件在雜湊表中獲得對應的Entry
  • 如果是第一次使用get()， 則使用 setInitialValue()呼叫使用者重寫的initialValue()方法建立map並使用使用者指定的值初始化。

在這種設計方式下，執行緒死去的時候，執行緒共享變數ThreadLocalMap會被銷燬。

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();
}

注意 Entry物件是弱引用：

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    // k: ThreadLocal, v: value
    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

弱引用的常見用法是：

WeakReference<RoleDTO> weakReference = new WeakReference<>(new RoleDTO());

因此，在Entry中，k 代表ThreadLocal物件，它是弱引用。v代表ThreadLocal管理的那個value，是強引用。

記憶體洩漏

記憶體洩漏是指無用物件（不再使用的物件）持續佔有記憶體或無用物件的記憶體得不到及時釋放，從而造成記憶體空間的浪費稱為記憶體洩漏。隨著垃圾回收器活動的增加以及記憶體佔用的不斷增加，程式效能會逐漸表現出來下降，極端情況下，會引發OutOfMemoryError導致程式崩潰。

記憶體洩漏問題主要線上程池中出現，因為執行緒池中的執行緒是不斷執行的，從任務佇列中不斷獲取新的任務執行。但是任務中可能有ThreadLocal物件，這些物件的ThreadLocal會儲存線上程的ThreadLocalMap中，因此ThreadLocalMap會越來越大。

但是ThreadLocal是由任務（worker）傳入的，一個任務執行結束後，對應的ThreadLocal物件會被銷燬。執行緒中的關係是： Thread -> ThreadLoalMap -> Entry<ThreadLocal, Object>。ThreadLocal由於是弱引用會，在GC的時候會被銷燬，這會導致 ThreadLoalMap中存在Entry<null, Object>。

使用remove()

由於執行緒池中的執行緒一直在執行，如果不對ThreadLoalMap進行清理，那Entry<null, Object>會一直佔用記憶體。remove()方法會清除key==null的Entry。

使用static修飾

將ThreadLocal設定成static可以避免一個執行緒類多次傳入執行緒池後重復建立Entry。例如，有一個使用者定義的執行緒

public class Test implements Runnable{
    private static ThreadLocal<Integer> local = new ThreadLocal<>();
    @Override
    public void run() {
        // do something
    }
}

使用執行緒池處理10個任務。那麼執行緒池中每個用來處理任務的執行緒的Thread.ThreadLocalMap中都會儲存一個Entry<local, Integer>，由於新增了static關鍵字，所有每個執行緒中的Entry中的local變數引用的都是同一個變數。這時就算發生記憶體洩漏，所有的Test類也只有一個local物件，不會導致記憶體佔用過多。

@Test
void contextLoads() {
   Runnable runnable = () -> {
      System.out.println(Thread.currentThread().getName());
   };

   for(int index = 1; index <= 10; ++index){
      taskExecutor2.submit(new com.example.test1.service.Test());
   }
}

相關文章