blocks|key|306467|text|当您有多个线程访问相同的资源时，您必须担心线程安全。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|306468|如果静态方法直接或间接地使用与其他线程相同的资源，那么即使这些资源不是静态类变量，它也可能是不安全的。|306469|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You have to worry about thread safety whenever you have more than one thread accessing the same resources. 

Your static method might be unsafe if it is using the same resources as other threads -- directly or indirectly -- even if those resources are not static class variables.

blocks|key|3970415|text|如果没有访问可变资源，那么它是线程安全的--但是，您必须确保您的方法不会调用访问任何可变资源的任何其他方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3970416|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 is thread-safe if no mutable resources, such as, class variables are accessed -- however, you have to make sure that your method does not call any other methods that access any mutable resources.

blocks|key|2375003|text|如果至少存在一个可由多个线程访问的单一入口点，则线程安全将成为一个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2375004|如果一段代码被多个线程访问并调用其他方法/类等，那么所有这些代码树都会变得易受攻击。|2375005|来自"Java并发实践“：围绕任务执行组织程序的ﬁ第一步是识别合理的任务边界。理想情况下，任务是独立的活动:不依赖于其他任务的状态、结果或副作用的工作。独立性促进了并发性，因为如果有足够的处理资源，可以并行执行独立的任务。|2375006|例如，如果您正在编写一个独立的servlet，该servlet保证由单个线程执行，则不必担心。但是，如果您编写了一个由不同servlet使用的静态实用程序，则必须使其能够处理多线程访问。|2375007|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|$]]

Thread safety becomes a concern if there is at least a single entry point which can be accessed by multiple threads.

If a piece of code is accessed by multiple threads and is calling other method/class/etc., then all this code tree becomes vulnerable.

From "Java concurrency in practice":
The ﬁrst step in organizing a program around task execution is identifying sensible task boundaries. Ideally, tasks are independent activities: work that doesn’t
depend on the state, result, or side effects of other tasks. Independence facilitates concurrency, as independent tasks can be executed in parallel if there are
adequate processing resources.

For example, if you are writing an isolated servlet, which is guaranteed to be executed by a single thread, you don't have to worry. But if you write a static utility which is used by different servlets, then it has to be made to handle multi-threaded access.

blocks|key|3970540|text|只要有多个线程访问相同的资源，并且这些资源不是一成不变的，您就必须担心线程安全。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3970541|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|$]]

You have to worry about thread safety whenever you have more than one thread accessing the same resources, and those resources are not immutable.

blocks|key|1505065|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1505066|如果我有一个不接触任何静态类级别变量的静态实用函数，那么这个方法已经是线程安全的了吗？|blockquote|1505067|1505068|1505069|大多数时候-重要的是你的方法是不是reentrant。这样的代码是可重入的，因为一切都是局部变量，每个线程都会收到自己的副本：|offset|length|1505070|static+int+add(int+a,+int+b)
{
++++return+a+%2B+b;
}|code-block|syntax|javascript|1505071|仍然有一些事情需要注意。如果您将一个对象传递给该方法，并且该方法更改了该对象，并且在该方法完成之前，您再次在不同的线程上调用相同的方法，但是使用相同的对象执行，那么您就有问题了。|style|BOLD|1505072|1505073|如果我有一个接触静态类变量的静态方法，那么这个方法有可能不是线程安全的吗？|1505074|1505075|1505076|主要的问题仍然是变量是否可变。如果你只是从不可变的对象中读取，那么可能没有任何问题。|1505077|如果你调用一个方法，你不确定它是否是可重入的，文档也没有说明，最好假设它不是可重入的。|1505078|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Reentrant_%2528subroutine%2529^0|0|0|0|0|H|9|0|0|0|27|A|0|0|0|11|0|0|0|0|16|0|0|17|0^^$0|@$1|2|3|-4|4|5|6|19|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1A|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1B|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1C|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|1D|7|@]|8|@$H|1E|I|1F|1|1G]]|9|$]]|$1|J|3|K|4|L|6|1H|7|@]|8|@]|9|$M|N]]|$1|O|3|P|4|5|6|1I|7|@$H|1J|I|1K|Q|R]]|8|@]|9|$]]|$1|S|3|-4|4|5|6|1L|7|@]|8|@]|9|$]]|$1|T|3|U|4|C|6|1M|7|@$H|1N|I|1O|Q|R]]|8|@]|9|$]]|$1|V|3|-4|4|5|6|1P|7|@]|8|@]|9|$]]|$1|W|3|-4|4|5|6|1Q|7|@]|8|@]|9|$]]|$1|X|3|Y|4|5|6|1R|7|@$H|1S|I|1T|Q|R]]|8|@]|9|$]]|$1|Z|3|10|4|5|6|1U|7|@$H|1V|I|1W|Q|R]]|8|@]|9|$]]|$1|11|3|-4|4|5|6|1X|7|@]|8|@]|9|$]]]|12|$13|$4|14|15|16|9|$17|18]]]]

<blockquote>
 If I have static utility function that doesn't touch any static class level variables, is that method already thread safe? 
</blockquote>

Most of the time - what matters is if your method is <a href="http://en.wikipedia.org/wiki/Reentrant_%28subroutine%29" rel="nofollow">reentrant</a>. Something like this is reentrant because everything is local variables and each thread receives its own copy:

<pre><code>static int add(int a, int b)
{
 return a + b;
}
</code></pre>

There are still some things to be careful of. If you pass in an object to the method and the method mutates the object and before the method completes you call the same method again on a different thread but with the same object, then you have a problem.

<blockquote>
 If I have a static method that does touch static class variables, is that method potentially not thread safe?
</blockquote>

The main issue again is if the variables are mutable. If you are only reading from immutable objects then there may not be any problem.

If you call a method and you are not sure if it is reentrant and the documentation doesn't say, it's best to assume that it isn't.

blocks|key|306662|text|如果您有一个方法可以写入跨多个线程共享的任何状态(例如，静态变量或多线程使用的任何对象)，那么该方法需要考虑线程安全性，读取任何共享状态的任何方法也是如此。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|306663|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|$]]

If you have a method that writes to any state that's shared across multiple threads (for example, static variables, or any objects that multiple threads use), then that method needs to worry about thread-safety, and so do any methods that read any of that shared state.

blocks|key|1505114|text|如果在静态方法中只使用局部堆栈变量，那么就没有理由担心。java.lang.Math.min(int，int)就是这种方法的一个很好的例子。但是如果你接触到任何共享的静态变量，或者有状态的对象(也不是不可变的)，那么你就必须使用同步。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1505115|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|$]]

If you using only local stack variables in static method then there is no reason to worry. java.lang.Math.min(int, int) is good example of such method. But in case if you touching any shared static variables, or objects which do have state (aka not immutable) then you have to use synchronization.

What are some situations where you need to worry about whether a static method is thread safe?

For example, if I have static utility function that doesn't touch any static class level variables, is that method already thread safe? If I have a static method that does touch static class variables, is that method potentially not thread safe?

Thanks in advance.

When do you have to worry about thread safety?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在哪些情况下，您需要担心静态方法是否是线程安全的？例如，如果我有一个不接触任何静态类级别变量的静态实用函数，那么该方法是否已经是线程安全的？如果我有一个接触静态类变量的静态方法，那么这个方法有可能不是线程安全的吗？提前谢谢。

问什么时候你需要担心线程安全呢？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候你需要担心线程安全呢？EN