blocks|key|252435|text|你被误导了。您所描述的内容实际上被称为不适当的发布，并在Java+Concurrency+in+Practice一书中详细讨论。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|252436|所以，是的，另一个线程有可能获得对您的对象的引用，并在它完成初始化之前开始尝试使用它。但等等，更糟糕的是考虑一下这个答案：https://stackoverflow.com/a/2624784/122207+...基本上，可以对引用赋值和构造函数完成进行重新排序。在引用的示例中，一个线程可以分配h+=+new+Holder(i)，另一个线程可以在新实例上调用h.assertSanity()，同时恰到好处地为在Holder的构造函数中分配的n成员获取两个不同的值。|offset|length|style|CODE|252437|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/2624784/122207^0|0|44|H|50|G|5Q|6|65|1|1P|16|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]|$D|T|E|U|F|G]|$D|V|E|W|F|G]|$D|X|E|Y|F|G]]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|H|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

You've been misinformed. What you describe is actually referred to as improper publication and discussed at length in the Java Concurrency In Practice book.

So yes, it will be possible for another thread to obtain a reference to your object and begin trying to use it before it is finished initializing. But wait, it gets worse consider this answer: <a href="https://stackoverflow.com/a/2624784/122207">https://stackoverflow.com/a/2624784/122207</a> ... basically there can be a reordering of reference assignment and constructor completion. In the example referenced, one thread can assign <code>h = new Holder(i)</code> and another thread call <code>h.assertSanity()</code> on the new instance with timing just right to get two different values for the <code>n</code> member that is assigned in <code>Holder</code>'s constructor.

blocks|key|252443|text|这不安全。在JVM中没有额外的同步。你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|252444|public+class+Test+{
++++private+final+Object+lock+=+new+Object();
++++public+Test()+{
++++++++synchronized+(lock)+{
++++++++++++//+your+improper+object+reference+publication
++++++++++++//+long+initialization
++++++++}
++++}

++++public+void+doSomething()+{
++++++++synchronized+(lock)+{
++++++++++++//+do+something
++++++++}
++++}
}|code-block|syntax|javascript|252445|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It's unsafe. There are no additional synchronization in JVM. You can do something like this:

<pre><code>public class Test {
 private final Object lock = new Object();
 public Test() {
 synchronized (lock) {
 // your improper object reference publication
 // long initialization
 }
 }

 public void doSomething() {
 synchronized (lock) {
 // do something
 }
 }
}
</code></pre>

blocks|key|252470|text|构造函数就像其他方法一样，没有额外的同步(除了处理final字段)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|252471|如果稍后发布this，则代码可以正常工作|252472|public+Test()+
{
++++//+Some+lengthy+operation+to+fully+initialize+this+object

++++this.id+=+atomicIdGenerator.getAndIncrement();
++++testsById.put(this.id,+this);
}|code-block|syntax|javascript|252473|entityMap^0|P|5|0|6|4|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

constructors are just like other methods, there's no additional synchronization (except for handling <code>final</code> fields).

the code would work if <code>this</code> is published later

<pre><code>public Test() 
{
 // Some lengthy operation to fully initialize this object

 this.id = atomicIdGenerator.getAndIncrement();
 testsById.put(this.id, this);
}
</code></pre>

Someone somewhere told me that Java constructors are synchronized so that it can't be accessed concurrently during construction, and I was wondering: if I have a constructor that stores the object in a map, and another thread retrieves it from that map before its construction is finished, will that thread block until the constructor completes?

Let me demonstrate with some code:

<pre><code>public class Test {
 private static final Map&lt;Integer, Test&gt; testsById =
 Collections.synchronizedMap(new HashMap&lt;&gt;());
 private static final AtomicInteger atomicIdGenerator = new AtomicInteger();
 private final int id;

 public Test() {
 this.id = atomicIdGenerator.getAndIncrement();
 testsById.put(this.id, this);
 // Some lengthy operation to fully initialize this object
 }

 public static Test getTestById(int id) {
 return testsById.get(id);
 }
}
</code></pre>

Assume that put/get are the only operations on the map, so I won't get CME's via something like iteration, and try to ignore other obvious flaws here.

What I want to know is if another thread (that's not the one constructing the object, obviously) tries to access the object using <code>getTestById</code> and calling something on it, will it block? In other words:

<pre><code>Test test = getTestById(someId);
test.doSomething(); // Does this line block until the constructor is done?
</code></pre>

I'm just trying to clarify how far the constructor synchronization goes in Java and if code like this would be problematic. I've seen code like this recently that did this instead of using a static factory method, and I was wondering just how dangerous (or safe) this is in a multi-threaded system.

Constructor synchronization in Java

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

有人告诉我，Java构造函数是同步的，所以在构造期间不能并发访问，我想知道:如果我有一个将对象存储在map中的构造函数，而另一个线程在其构造完成之前从该map检索对象，那么该线程是否会阻塞，直到构造函数完成？让我用一些代码来演示：public class Test {    private static final M...

问Java中的构造函数同步
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的构造函数同步EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的构造函数同步
EN