1.学習目標
1. ThreadLocalはどのような問題を解決できますか？
2.同期および揮発性に対するThreadLocalの利点は何ですか？
- 同期：並行性の量が少ない場合は問題ありません。並行性の量が多い場合、同じオブジェクトロックを待機するスレッドが多数存在するため、システムのスループットが急落します。
- 揮発性：変更された変数はコピーを保持せず、メインメモリに直接アクセスします。主に、1回の書き込みと複数回の読み取りが行われるシナリオで使用されます。
- ThreadLocal：各スレッドの変数のコピーを作成して、各スレッドアクセスが互いに分離された独自のコピーであることを確認します。スレッドセーフの問題は発生しません。
第二に、ThreadLocalの使用
1.スレッドは安全ではありません：
public class ThreadA extends Thread {
private int i;
private UnsafeThread unsafeThread;
ThreadA(int i, UnsafeThread unsafeThread) {
this.i = i;
this.unsafeThread = unsafeThread;
}
@Override
public void run() {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
unsafeThread.calc();
System.out.println("i:" + i + ",count:" + unsafeThread.getCount());
}
}
public class UnsafeThread {
private int count = 0;
public void calc() {
count++;
}
public int getCount() {
return count;
}
public static void main(String[] args) throws InterruptedException {
UnsafeThread testThread = new UnsafeThread();
for (int i = 0; i < 20; i++) {
new ThreadA(i, testThread).start();
}
Thread.sleep(200);
System.out.println("realCount:" + testThread.getCount());
}
}
演算結果：
i:6,count:8
i:0,count:8
i:17,count:13
i:7,count:8
i:2,count:8
i:11,count:8
i:8,count:11
i:5,count:11
i:13,count:11
i:15,count:11
i:14,count:11
i:10,count:8
i:3,count:11
i:12,count:11
i:9,count:8
i:19,count:15
i:4,count:15
i:16,count:15
i:1,count:15
i:18,count:15
realCount:15
私たちは見ることができます：スレッドセーフの問題があります
- RealCountが最終的にエラーになり、期待される結果は20になるはずですが、実際の状況は15です。
- 重複カウント
2. ThreadLocalに参加し、スレッドセーフ：
public class ThreadA extends Thread {
private int i;
private UnsafeThread unsafeThread;
ThreadA(int i, UnsafeThread unsafeThread) {
this.i = i;
this.unsafeThread = unsafeThread;
}
@Override
public void run() {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
unsafeThread.calc();
System.out.println("i:" + i + ",count:" + unsafeThread.getCount());
}
}
public class SafeThread {
private ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
private int count = 0;
public void calc() {
threadLocal.set(count + 1);
}
public int getCount() {
Integer integer = threadLocal.get();
return integer != null ? integer : 0;
}
public static void main(String[] args) throws InterruptedException {
SafeThread testThreadLocal = new SafeThread();
for (int i = 0; i < 20; i++) {
new ThreadB(i, testThreadLocal).start();
}
Thread.sleep(200);
System.out.println("realCount:" + testThreadLocal.getCount());
}
}
演算結果：
i:1,count:1
i:10,count:1
i:4,count:1
i:11,count:1
i:6,count:1
i:7,count:1
i:9,count:1
i:3,count:1
i:12,count:1
i:0,count:1
i:5,count:1
i:8,count:1
i:2,count:1
i:13,count:1
i:17,count:1
i:18,count:1
i:15,count:1
i:19,count:1
i:16,count:1
i:14,count:1
realCount:0
3、ThreadLocalの動作原理
1.スレッドは安全ではありません：
複数のスレッドが同時にパブリックリソースカウントにアクセスできることがわかります。スレッドがcount ++を実行している場合、他のスレッドも同時にcount ++を実行する可能性があります。ただし、複数のスレッド変数カウントが表示されないため、他のスレッドは古いカウント値+1を取得するため、realCountが20であると予想されるが、実際には15であるというデータの問題があります。
2.スレッドセーフ：
写真が示すように：
- より大きな方向では、ThreadLocalは各スレッドの変数のコピーを作成して、各スレッドアクセスが互いに分離された独自のコピーであることを確認します。
- 小さな意味で、各スレッドにはthreadLocalMapがあり、各threadLocalMapにはエントリ配列が含まれており、エントリはthreadLocalとデータ（ここではcount）で構成されています。
このように、各スレッドには独自の変数カウントがあります。
例2では、スレッド1がcalcメソッドを呼び出すと、最初にgetCountメソッドが呼び出されます。threadLocal.get（）への最初の呼び出しは空を返すため、getCountの戻り値は0です。このようにして、threadLocal.set（getCount（）+ 1）はthreadLocal.set（0 + 1）になり、スレッド1のthreadLocalのデータ値を1に設定します。
スレッド2はcalcメソッドを再度呼び出し、getCountメソッドも最初に呼び出します。threadLocal.get（）への最初の呼び出しは空を返すため、getCountの戻り値も0になります。このようにして、threadLocal.set（getCount（）+ 1）は、スレッド2のthreadLocalのデータ値も1に設定します。
…
最後に、各スレッドのthreadLocalのデータ値は1です。
また、例2 0でrealCountが出力されるのはなぜですか？
- testThreadLocal.getCount（）はメインスレッドで呼び出されるため、他のスレッドの変更はそれ自体のコピーにのみ影響し、元の変数には影響しません。countの初期値は0であるため、最後は0のままです。
4、ThreadLocalソースコード分析
1、スレッド：
ThreadLocal.ThreadLocalMap threadLocals = null;
threadLocalsというメンバー変数が定義されており、そのタイプはThreadLocal.ThreadLocalMapです。明らかに、ThreadLocalMapはThreadLocalの内部クラスであり、図に描いたものを検証します。各スレッドにはThreadLocalMapオブジェクトがあります。
2、ThreadLocalMap：
static class ThreadLocalMap {
// Entry是WeakReference（弱引用）的子类
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
// Entry 包含了 ThreadLocal变量 和Object的value
Entry(ThreadLocal<?> k, Object v) {
// ThreadLocal变量做为WeakReference的referen
super(k);
value = v;
}
}
private static final int INITIAL_CAPACITY = 16;
// 数组，它的类型是Entry
private Entry[] table;
private int size = 0;
private int threshold; // Default to 0
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
...
}
3、ThreadLocal＃get（）：
public T get() {
//获取当前线程
Thread t = Thread.currentThread();
//获取当前线程中的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
//如果可以查询到数据
if (map != null) {
//从ThreadLocalMap中获取entry对象
ThreadLocalMap.Entry e = map.getEntry(this);
//如果entry存在
if (e != null) {
@SuppressWarnings("unchecked")
//获取entry中的值
T result = (T)e.value;
//返回获取到的值
return result;
}
}
//调用初始化方法，返回null
return setInitialValue();
}
ThreadLocal＃getMap（t）：
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
実際、Threadクラスの変数は次のように呼び出されます。
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal＃getEntry（ThreadLocal <？>キー）：
private Entry getEntry(ThreadLocal<?> key) {
//threadLocalHashCode是key的hash值
//key.threadLocalHashCode & (table.length - 1)，
//相当于threadLocalHashCode对table.length - 1的取余操作，
//这样可以保证数组的下表在0到table.length - 1之间。
int i = key.threadLocalHashCode & (table.length - 1);
//获取下标对应的entry
Entry e = table[i];
//如果entry不为空，并且从弱引用中获取到的值(threadLocal) 和 key相同
if (e != null && e.get() == key)
//返回获取到的entry
return e;
else
//如果没有获取到entry或者e.get()获取不到数据，则清理空数据
return getEntryAfterMiss(key, i, e);
}
エントリはWeakReferenceのサブクラスであり、e.get（）メソッドは次を呼び出します。Refernt＃get（）
public T get() {
return this.referent;
}
返されるのは参照です。これは、コンストラクターによって渡されたthreadLocalオブジェクトです。
ThreadLocal＃getEntryAfterMiss（ThreadLocal <？> key、int i、Entry e）
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;
}
このメソッドはexpungeStaleEntryメソッドを呼び出します。これについては後で説明します。
ThreadLocal＃setInitialValue（）：
private T setInitialValue() {
//调用用户自定义的initialValue方法，默认值是null
T value = initialValue();
//获取当前线程
Thread t = Thread.currentThread();
//获取当前线程中的ThreadLocalMap，跟之前一样
ThreadLocalMap map = getMap(t);
//如果ThreadLocalMap不为空，
if (map != null)
//则覆盖key为当前threadLocal的值
map.set(this, value);
else
//否则创建新的ThreadLocalMap
createMap(t, value);
//返回用户自定义的值
return value;
}
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);
}
ThreadLocal.ThreadLocalMap＃set（ThreadLocal <？>キー、オブジェクト値）：
private void set(ThreadLocal<?> key, Object value) {
//将table数组赋值给新数组tab
Entry[] tab = table;
//获取数组长度
int len = tab.length;
//跟之前一样计算数组中的下表
int i = key.threadLocalHashCode & (len-1);
//循环变量tab获取entry
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
//获取entry中的threadLocal对象
ThreadLocal<?> k = e.get();
//如果threadLocal对象不为空，并且等于key
if (k == key) {
//覆盖已有数据
e.value = value;
//返回
return;
}
//如果threadLocal对象为空
if (k == null) {
//创建一个新的entry赋值给已有key
replaceStaleEntry(key, value, i);
return;
}
}
//如果key不在已有数据中，则创建一个新的entry
tab[i] = new Entry(key, value);
//长度+1
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
replaceStaleEntryメソッドは、expungeStaleEntryメソッドも呼び出します。
5、ThreadLocal＃remove（）：
public void remove() {
//还是那个套路，不过简化了一下
//先获取当前线程，再获取线程中的ThreadLocalMap对象
ThreadLocalMap m = getMap(Thread.currentThread());
//如果ThreadLocalMap不为空
if (m != null)
//删除数据
m.remove(this);
}
ThreadLocal.ThreadLocalMap＃remove（ThreadLocal <？>キー）：
private void remove(ThreadLocal<?> key) {
//将table数组赋值给新数组tab
Entry[] tab = table;
//获取数组长度
int len = tab.length;
//跟之前一样计算数组中的下表
int i = key.threadLocalHashCode & (len-1);
//循环变量从下表i之后不为空的entry
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
//如果可以获取到threadLocal并且值等于key
if (e.get() == key) {
//清空引用
e.clear();
//处理threadLocal为空但是value不为空的entry
expungeStaleEntry(i);
return;
}
}
}
clearメソッドも非常に簡単です。参照をnullに設定するだけです。つまり、参照をクリアします。
public void clear() {
this.referent = null;
}
ThreadLocal＃expungeStaleEntry（int staleSlot）
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
//将位置staleSlot对应的entry中的value设置为null，有助于垃圾回收
tab[staleSlot].value = null;
//将位置staleSlot对应的entry设置为null，有助于垃圾回收
tab[staleSlot] = null;
//数组大小-1
size--;
Entry e;
int i;
//变量staleSlot之后entry不为空的数据
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
//获取当前位置的entry中对应的threadLocal
ThreadLocal<?> k = e.get();
//threadLocal为空，说明是脏数据
if (k == null) {
//value设置为null，有助于垃圾回收
e.value = null;
//当前位置的entry设置为null
tab[i] = null;
//数组大小-1
size--;
} else {
//重新计算位置
int h = k.threadLocalHashCode & (len - 1);
//如果h和i不相等，说明存在hash冲突
//现在它前面的脏Entry被清理
//该Entry需要向前移动，防止下次get()或set()的时候
//再次因散列冲突而查找到null值
if (h != i) {
tab[i] = null;
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
このメソッドは、最初に現在の位置にあるダーティエントリをクリアし、次にtable [i] == nullになるまで逆方向にトラバースします。トラバーサルの過程で、ダーティエントリが再び検出されると、クリーンアップされます。
検出されない場合は、現在検出されているエントリを再可変します。再ハッシュの添え字hが現在の添え字iと矛盾する場合は、エントリがエントリ配列に配置されたときにハッシュの競合が発生したことを意味します。ハッシュは後方にシフトされます）、クリアされる前にダーティエントリが移動するため、現在のエントリは前方に移動して空の位置を埋める必要があります。それ以外の場合は、次にset（）またはget（）メソッドを呼び出してエントリを検索するときに、前のnull値が検索されます。
なぜそのような除去をするのですか？
- エントリオブジェクトにはthreadLocalとvalueが含まれていることがわかっています。threadLocalはWeakReference（弱参照）の指示対象です。ガベージコレクション期間がGCをトリガーするたびに、WeakReferenceの指示対象がリサイクルされ、指示対象がnullに設定されます。その場合、threadLocal = nullのエントリが多数ありますが、テーブル配列の値は空ではありません。そのようなエントリの存在には実際の値はありません。
- この種のデータには、if（e！= null && e.get（）== key）という文が含まれているため、getEntryを介して値を取得することはできません。
なぜWeakReference（弱参照）を使用するのですか？
- メモリリークを回避する：強力な参照を使用すると、ThreadLocalはユーザープロセスで参照されなくなりますが、スレッドが終了しない限り、ThreadLocalMapに参照が残り、GCでリサイクルできないため、メモリが発生します。リーク。
- さらに、スレッドプールテクノロジを使用する場合、スレッドは破棄されないため、リサイクル後に再利用されます。これにより、ThreadLocalを解放できなくなり、最終的にメモリリークが発生します。
4、ThreadLocalの落とし穴は何ですか
1.メモリリークの問題：
ThreadLocalがWeakReference（弱参照）を使用している場合でも、エントリオブジェクトではキー（つまりthreadLocalオブジェクト）のみが弱参照として設定されているため、メモリリークの問題が発生する可能性がありますが、値の値は設定されていません。次の強い依存関係が引き続き存在します。
Thread -> ThreaLocalMap -> Entry -> value
解決：
- get（）、set（T value）を呼び出しますが、get（）およびset（T value）メソッドは、ガベージコレクターがキーを収集した後にトリガーされるデータクリーンアップに基づいています。ガベージコレクターが時間内に収集されない場合は、問題もあります。
- remove（）を呼び出すと、このメソッドはエントリ内のキー（つまりthreadLocalオブジェクト）と値を一緒にクリアします。
2.スレッドセーフの問題：
threadLocalを使用すればスレッドセーフの問題は発生しないと考える友人もいるかもしれませんが、実際には間違っています。静的変数countを定義する場合、マルチスレッドの場合、threadLocalの値を変更して、countの値を設定する必要があり、これも問題があります。静的変数は複数のスレッドで共有されるため、個別に保存されなくなります。
5.要約：
1.各スレッドにはthreadLocalMapオブジェクトがあり、各threadLocalMapにはエントリ配列が含まれており、エントリはキー（つまりthreadLocal）と値（データ）で構成されています。
2.エントリのキーは弱参照であり、ガベージコレクタによってリサイクルできます。
3. threadLocalの最も一般的に使用される4つのメソッド：get（）、initialValue（）、set（T value）、remove（）。initialValueメソッドを除いて、他のメソッドはexpungeStaleEntryメソッドを呼び出してkey ==でデータをクリーンアップします。 null。ガベージコレクションを容易にするため。
4. get（）およびset（T value）を呼び出しますが、get（）およびset（T value）メソッドは、ガベージコレクターがキーを収集した後にトリガーされるデータクリーンアップに基づいています。ガベージコレクターが時間内に収集されない場合は、メモリリークの問題もあります。最も安全なのは、threadLocalを使用した後に手動でremoveメソッドを呼び出すことです。ソースコードからわかるように、このメソッドはのキーを変更します。エントリ（つまり、threadLocalオブジェクト）と値は一緒にクリアされます。