blocks|key|1182893|text|因为如果它是一个实例级字段，那么它实际上应该是"Per+Thread+-+Per+Instance"，而不仅仅是一个保证的"Per+Thread“。这通常不是您要寻找的语义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1182894|通常，它包含一些对象，这些对象的作用域是用户对话、Web请求等。您不希望它们也被作用子作用域到类的实例。|1182895|一个web请求=>一个持久化会话。|1182896|没有一个web请求=>每个对象一个持久化会话。|1182897|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Because if it were an instance level field, then it would actually be "Per Thread - Per Instance", not just a guaranteed "Per Thread." That isn't normally the semantic you're looking for. 

Usually it's holding something like objects that are scoped to a User Conversation, Web Request, etc. You don't want them also sub-scoped to the instance of the class. 
One web request => one Persistence session. 
Not one web request => one persistence session per object.

blocks|key|435617|text|要么让它成为静态的，要么如果你试图避免在你的类中有任何静态字段--让类本身成为一个单例，然后你就可以安全地使用一个实例级的ThreadLocal，只要你拥有全局可用的单例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|435618|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Either make it static or if you are trying to avoid any static fields in your class - make the class itself a singleton and then you can safely use the an instance level ThreadLocal as long as you have that singleton available globally.

blocks|key|435603|text|这并不是必须的。重要的是它应该是单例的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|435604|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It doesn't have to be. The important thing is that it should be a singleton.

blocks|key|435587|text|原因是变量是通过与线程相关联的指针访问的。它们的行为类似于具有线程作用域的全局变量，因此static是最合适的。这是获取线程本地状态的方法，比如pthread，所以这可能只是一个历史和实现的意外。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|435588|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The reason is that the variables are accessed via a pointer associated with the thread. They act like global variables with thread scope, hence static is the closest fit. This is the way that you get thread local state in things like pthreads so this might just be an accident of history and implementation.

blocks|key|1832316|text|请参考this，这将使您更好地理解。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1832317|简而言之，ThreadLocal对象就像一个键值映射。当线程调用ThreadLocal+get/set方法时，它将检索/存储映射的键中的线程对象，以及映射的值中的值。这就是为什么不同的线程具有不同的值副本(您希望将其存储在本地)，因为它驻留在不同的map条目中。|style|CODE|1832318|这就是为什么你只需要一个映射来保存所有的值。虽然不是必须的，但是你可以有多个map+(不需要声明static)来保持每个线程对象，这是完全多余的，这就是为什么静态变量是首选的。|1832319|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/36893654/1542363^0|3|4|0|0|5|B|W|B|18|7|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@$A|W|B|X|F|G]|$A|Y|B|Z|F|G]|$A|10|B|11|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

Refer to <a href="https://stackoverflow.com/a/36893654/1542363">this</a>, this give better understanding.

In short, <code>ThreadLocal</code> object work like a key-value map. When the thread invoke <code>ThreadLocal</code> <code>get/set</code> method, it will retrieve/store the thread object in the map's key, and the value in the map's value. That's why different threads has different copied of value (that you want to store locally), because it resides in different map's entry.

That's why you only need one map to keep all values. Although not necessary, you can have multiple map (without declare static) to keep each thread object as well, which, it is totally redundant, that's why static variable is preferred.

blocks|key|1832286|text|在每个线程的每个实例上使用threadlocal的用法是，如果您希望某个对象的所有方法中都可见某些内容，并使其线程安全，而不像对普通字段那样同步访问它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1832287|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A use for an threadlocal on a per instance per thread is if you want something to be visible in all methods of an object and have it thread safe without synchronizing access to it like you would so for an ordinary field.

blocks|key|3239976|text|static+final+ThreadLocal变量是线程安全的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3239977|static使ThreadLocal变量在多个类中仅可用于相应的线程。它是跨多个类的各个线程局部变量的一种全局变量分解。|3239978|我们可以用下面的代码示例来检查this线程的安全性。|3239979|3239980|CurrentUser+-将当前用户id存储在ThreadLocal|unordered-list-item|3239981|TestService中-使用从CurrentUser.|3239982|TestThread获取当前用户的方法-+concurrently|3239983|的简单服务-这个类用于创建多个线程并设置userid+getUser()|3239984|。|3239985|public+class+CurrentUser

public+class+CurrentUser+{
private+static+final+ThreadLocal<String>+CURRENT+=+new+ThreadLocal<String>();

public+static+ThreadLocal<String>+getCurrent()+{
++++return+CURRENT;
}

public+static+void+setCurrent(String+user)+{
++++CURRENT.set(user);
}

}

public+class+TestService+{

public+String+getUser()+{
++++return+CurrentUser.getCurrent().get();
}

}|code-block|syntax|javascript|3239986|3239987|import+java.util.ArrayList;
import+java.util.List;

public+class+TestThread+{

public+static+void+main(String[]+args)+{

++List<Integer>+integerList+=+new+ArrayList<>();

++//creates+a+List+of+100+integers
++for+(int+i+=+0;+i+<+100;+i%2B%2B)+{

++++integerList.add(i);
++}

++//parallel+stream+to+test+concurrent+thread+execution
++integerList.parallelStream().forEach(intValue+->+{

++++//All+concurrent+thread+will+set+the+user+as+"intValue"
++++CurrentUser.setCurrent(""+%2B+intValue);
++++//Thread+creates+a+sample+instance+for+TestService+class
++++TestService+testService+=+new+TestService();
++++//Print+the+respective+thread+name+along+with+"intValue"+value+and+current+user.+
++++System.out.println("Start-"%2BThread.currentThread().getName()%2B"->"%2BintValue+%2B+"->"+%2B+testService.getUser());

++++try+{
++++++//all+concurrent+thread+will+wait+for+3+seconds
++++++Thread.sleep(3000l);
++++}+catch+(InterruptedException+e)+{
++++++//+TODO+Auto-generated+catch+block
++++++e.printStackTrace();
++++}

++++//Print+the+respective+thread+name+along+with+"intValue"+value+and+current+user.
++++System.out.println("End-"%2BThread.currentThread().getName()%2B"->"%2BintValue+%2B+"->"+%2B+testService.getUser());
++});

}

}|3239988|3239989|运行TestThread主类。输出-|3239990|Start-main->62->62
Start-ForkJoinPool.commonPool-worker-2->31->31
Start-ForkJoinPool.commonPool-worker-3->81->81
Start-ForkJoinPool.commonPool-worker-1->87->87
End-main->62->62
End-ForkJoinPool.commonPool-worker-1->87->87
End-ForkJoinPool.commonPool-worker-2->31->31
End-ForkJoinPool.commonPool-worker-3->81->81
Start-ForkJoinPool.commonPool-worker-2->32->32
Start-ForkJoinPool.commonPool-worker-3->82->82
Start-ForkJoinPool.commonPool-worker-1->88->88
Start-main->63->63
End-ForkJoinPool.commonPool-worker-1->88->88
End-main->63->63
...|3239991|分析总结|3239992|3239993|"main“线程启动，当前用户设置为"62"，并行"ForkJoinPool.commonPool-worker-2”线程启动，当前用户设置为"31"，并行"ForkJoinPool.commonPool-worker-3“线程启动，当前用户设置为"81”。并行"ForkJoinPool.commonPool-worker-1“线程启动并将当前用户设置为"87”Start-main->62->62+Start-ForkJoinPool.commonPool-worker-2->31->31+Start-ForkJoinPool.commonPool-worker-3->81->81+Start-ForkJoinPool.commonPool-worker-1->87->87|ordered-list-item|3239994|All以上线程将休眠3次seconds|3239995|main执行结束并将当前用户打印为"62"，并行ForkJoinPool.commonPool-worker-1执行结束并将当前用户打印为"87"，并行ForkJoinPool.commonPool-worker-2执行结束并将当前用户打印为"31"，parallely+ForkJoinPool.commonPool-worker-3执行结束并将当前用户打印为"81"|3239996|3239997|推理|3239998|并发线程能够检索正确的用户it，即使它声明为"static+final+ThreadLocal“|3239999|entityMap^0|0|O|0|0|6|0|0|0|0|B|0|0|B|0|0|A|0|R|9|0|0|0|0|0|0|0|0|0|0|0|0|0|4|O|W|24|W|3S|W|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1P|8|@$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1V|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]|$1|K|3|L|5|M|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|N|3|O|5|M|7|20|8|@$9|21|A|22|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|M|7|23|8|@$9|24|A|25|B|C]]|D|@]|E|$]]|$1|R|3|S|5|6|7|26|8|@$9|27|A|28|B|C]]|D|@]|E|$]]|$1|T|3|U|5|6|7|29|8|@]|D|@]|E|$]]|$1|V|3|W|5|X|7|2A|8|@]|D|@]|E|$Y|Z]]|$1|10|3|U|5|6|7|2B|8|@]|D|@]|E|$]]|$1|11|3|12|5|X|7|2C|8|@]|D|@]|E|$Y|Z]]|$1|13|3|U|5|6|7|2D|8|@]|D|@]|E|$]]|$1|14|3|15|5|6|7|2E|8|@]|D|@]|E|$]]|$1|16|3|17|5|X|7|2F|8|@]|D|@]|E|$Y|Z]]|$1|18|3|19|5|6|7|2G|8|@]|D|@]|E|$]]|$1|1A|3|-4|5|6|7|2H|8|@]|D|@]|E|$]]|$1|1B|3|1C|5|1D|7|2I|8|@]|D|@]|E|$]]|$1|1E|3|1F|5|1D|7|2J|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|1D|7|2K|8|@$9|2L|A|2M|B|C]|$9|2N|A|2O|B|C]|$9|2P|A|2Q|B|C]|$9|2R|A|2S|B|C]]|D|@]|E|$]]|$1|1I|3|-4|5|6|7|2T|8|@]|D|@]|E|$]]|$1|1J|3|1K|5|6|7|2U|8|@]|D|@]|E|$]]|$1|1L|3|1M|5|6|7|2V|8|@]|D|@]|E|$]]|$1|1N|3|-4|5|6|7|2W|8|@]|D|@]|E|$]]]|1O|$]]

<code>static final ThreadLocal</code> variables are thread safe.

<code>static</code> makes the ThreadLocal variable available across multiple classes for the respective thread only. it's a kind of Global variable decaration of the respective thread local variables across multiple classes.

We can check the this thread safety with the following code sample.

<ul>
<li><code>CurrentUser</code> - stores the current user id in ThreadLocal</li>
<li><code>TestService</code> - Simple service with method - <code>getUser()</code> to fetch the current user from CurrentUser.</li>
<li><code>TestThread</code> - this class used for creating multiple threads and set userids concurrently</li>
</ul>

.

<pre><code>public class CurrentUser

public class CurrentUser {
private static final ThreadLocal&lt;String&gt; CURRENT = new ThreadLocal&lt;String&gt;();

public static ThreadLocal&lt;String&gt; getCurrent() {
 return CURRENT;
}

public static void setCurrent(String user) {
 CURRENT.set(user);
}

}

public class TestService {

public String getUser() {
 return CurrentUser.getCurrent().get();
}

}
</code></pre>

.

<pre><code>import java.util.ArrayList;
import java.util.List;

public class TestThread {

public static void main(String[] args) {

 List&lt;Integer&gt; integerList = new ArrayList&lt;&gt;();

 //creates a List of 100 integers
 for (int i = 0; i &lt; 100; i++) {

 integerList.add(i);
 }

 //parallel stream to test concurrent thread execution
 integerList.parallelStream().forEach(intValue -&gt; {

 //All concurrent thread will set the user as "intValue"
 CurrentUser.setCurrent("" + intValue);
 //Thread creates a sample instance for TestService class
 TestService testService = new TestService();
 //Print the respective thread name along with "intValue" value and current user. 
 System.out.println("Start-"+Thread.currentThread().getName()+"-&gt;"+intValue + "-&gt;" + testService.getUser());

 try {
 //all concurrent thread will wait for 3 seconds
 Thread.sleep(3000l);
 } catch (InterruptedException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }

 //Print the respective thread name along with "intValue" value and current user.
 System.out.println("End-"+Thread.currentThread().getName()+"-&gt;"+intValue + "-&gt;" + testService.getUser());
 });

}

}
</code></pre>

.

Run TestThread main class.
Output - 

<pre><code>Start-main-&gt;62-&gt;62
Start-ForkJoinPool.commonPool-worker-2-&gt;31-&gt;31
Start-ForkJoinPool.commonPool-worker-3-&gt;81-&gt;81
Start-ForkJoinPool.commonPool-worker-1-&gt;87-&gt;87
End-main-&gt;62-&gt;62
End-ForkJoinPool.commonPool-worker-1-&gt;87-&gt;87
End-ForkJoinPool.commonPool-worker-2-&gt;31-&gt;31
End-ForkJoinPool.commonPool-worker-3-&gt;81-&gt;81
Start-ForkJoinPool.commonPool-worker-2-&gt;32-&gt;32
Start-ForkJoinPool.commonPool-worker-3-&gt;82-&gt;82
Start-ForkJoinPool.commonPool-worker-1-&gt;88-&gt;88
Start-main-&gt;63-&gt;63
End-ForkJoinPool.commonPool-worker-1-&gt;88-&gt;88
End-main-&gt;63-&gt;63
...
</code></pre>

Analysis summary 

<ol>
<li>"main" thread starts and set current user as "62", parallely "ForkJoinPool.commonPool-worker-2" thread starts and set current user as "31", parallely "ForkJoinPool.commonPool-worker-3" thread starts and set current user as "81", parallely "ForkJoinPool.commonPool-worker-1" thread starts and set current user as "87"
Start-main->62->62
Start-ForkJoinPool.commonPool-worker-2->31->31
Start-ForkJoinPool.commonPool-worker-3->81->81
Start-ForkJoinPool.commonPool-worker-1->87->87</li>
<li>All these above threads will sleep for 3 seconds</li>
<li><code>main</code> execution ends and print the current user as "62", parallely <code>ForkJoinPool.commonPool-worker-1</code> execution ends and print the current user as "87", parallely <code>ForkJoinPool.commonPool-worker-2</code> execution ends and print the current user as "31",
parallely <code>ForkJoinPool.commonPool-worker-3</code> execution ends and print the current user as "81"</li>
</ol>

Inference

Concurrent Threads are able to retrieve correct userids even if it has declared as "static final ThreadLocal"

I was reading the JavaDoc for Threadlocal here

<a href="https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/ThreadLocal.html" rel="noreferrer">https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/ThreadLocal.html</a>

and it says
"ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID). "

But my question is why did they choose to make it static (typically) - it makes things a bit confusing to have "per thread" state but the fields are static?

Why should Java ThreadLocal variables be static

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我在这里阅读线程本地的JavaDoc它说"ThreadLocal实例通常是类中的私有静态字段，它们希望将状态与线程(例如，用户ID或事务ID)相关联。“但我的问题是，为什么他们选择将其设置为静态的(通常)-这会使事情变得有点混乱，因为有“每个线程”的状态，但字段是静态的？

问为什么Java ThreadLocal变量应该是静态的
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么Java ThreadLocal变量应该是静态的EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么Java ThreadLocal变量应该是静态的
EN