blocks|key|938449|text|Implementing+the+Singleton+Pattern+in+C#在第三版中谈到了这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|938450|上面写着：|938451|938452|使实例变量易失性可以让它工作，显式内存屏障调用也可以，尽管在后一种情况下，即使是专家也不能确切地同意需要哪些屏障。我倾向于避免专家不同意什么是对什么是错的情况！|blockquote|938453|938454|938455|作者似乎暗示，与其他策略相比，双重锁定不太可能奏效，因此不应使用。|938456|entityMap|0|LINK|mutability|MUTABLE|url|https://csharpindepth.com/Articles/Singleton#dcl^0|0|14|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|10|8|@]|9|@]|C|$]]|$1|G|3|H|5|I|7|11|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|12|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|14|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]]]

<a href="https://csharpindepth.com/Articles/Singleton#dcl" rel="nofollow noreferrer">Implementing the Singleton Pattern in C#</a> talks about this problem in the third version.

It says:

<blockquote>
 Making the instance variable volatile can make it work, as would explicit memory barrier calls, although in the latter case even experts can't agree exactly which barriers are required. I tend to try to avoid situations where experts don't agree what's right and what's wrong!
</blockquote>

The author seems to imply that double locking is less likely to work than other strategies and thus should not be used.

blocks|key|938501|text|双重检查锁定现在可以在Java和C#中工作(+Java内存模型改变了，这是其中一个效果)。然而，你必须让它完全正确。如果你把事情搞得一团糟，你很可能最终失去线程的安全性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|938502|正如其他答案所述，如果您正在实现singleton+pattern，那么有更好的方法来实现它。就我个人而言，如果我处于一种情况下，我必须在自己实现双重检查锁定和“每次锁定”代码之间做出选择，我会选择每次都锁定，直到我得到真正的证据表明它造成了瓶颈。当谈到线程时，一个简单且明显正确的模式是非常有价值的。|offset|length|938503|entityMap|0|LINK|mutability|MUTABLE|url|http://pobox.com/%257Eskeet/csharp/singleton.html^0|0|G|H|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Double-checking locking now works in Java as well as C# (the Java memory model changed and this is one of the effects). However, you have to get it exactly right. If you mess things up even slightly, you may well end up losing the thread safety.
As other answers have stated, if you're implementing the <a href="http://pobox.com/%7Eskeet/csharp/singleton.html" rel="nofollow noreferrer">singleton pattern</a> there are much better ways to do it. Personally, if I'm in a situation where I have to choose between implementing double-checked locking myself and &quot;lock every time&quot; code I'd go for locking every time until I'd got real evidence that it was causing a bottleneck. When it comes to threading, a simple and obviously-correct pattern is worth a lot.

blocks|key|4216493|text|.NET+4.0有一个新的类型：Lazy<T>，它消除了人们对错误模式的担忧。它是新的任务并行库的一部分。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4216494|请参阅MSDN并行计算开发人员中心：http://msdn.microsoft.com/en-us/concurrency/default.aspx|4216495|顺便说一句，.NET+3.5+SP1+available+here有一个后端口(我相信它不受支持)。|4216496|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/concurrency/default.aspx|1|http://msdn.microsoft.com/en-us/devlabs/ee794896.aspx^0|G|7|0|I|1K|0|0|T|4|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|H|3|I|5|6|7|10|8|@]|D|@$9|11|A|12|1|13]]|E|$]]|$1|J|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]]]

.NET 4.0 has a new type: <code>Lazy&lt;T&gt;</code> that takes away any concern about getting the pattern wrong. It's part of the new Task Parallel Library.

See the MSDN Parallel Computing Dev Center: <a href="http://msdn.microsoft.com/en-us/concurrency/default.aspx" rel="noreferrer">http://msdn.microsoft.com/en-us/concurrency/default.aspx</a>

BTW, there's a backport (I believe it is unsupported) for .NET 3.5 SP1 available <a href="http://msdn.microsoft.com/en-us/devlabs/ee794896.aspx" rel="noreferrer">here</a>.

blocks|key|3370128|text|注意，在Java语言中(很可能在.Net中也是如此)，对单例初始化的双重检查锁定是完全不必要的，也是不必要的。因为类只有在第一次使用时才会被初始化，所以所需的惰性初始化已经通过这个方法实现了；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3370129|private+static+Singleton+instance+=+new+Singleton();|code-block|syntax|javascript|3370130|除非您的Singleton类包含可能在首次使用Singleton实例之前访问的常量之类的内容，否则这就是您需要做的全部工作。|3370131|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Note than in Java (and most likely in .Net as well), double-checked locking for singleton initialization is completely unnecessary as well as broken. Since classes are not initialized until they're first used, the desired lazy initialization is already achieved by this;

<pre><code>private static Singleton instance = new Singleton();
</code></pre>

Unless your Singleton class contains stuff like constants that may be accessed before a Singleton instance is first used, this is all you need to do.

blocks|key|152881|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|152882|通过使用布尔值(即使用原语来避免延迟初始化)，我已经获得了双重检查锁定：|blockquote|152883|152884|152885|使用布尔值的单例不起作用。不同线程之间的操作顺序是不能保证的，除非您通过内存屏障。换言之，从第二线程看，可以在instance=+new+Singleton();之前执行created+=+true|offset|length|style|CODE|152886|entityMap^0|0|0|0|0|1J|Q|2D|E|0^^$0|@$1|2|3|-4|4|5|6|N|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|O|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|P|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|Q|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|R|7|@$H|S|I|T|J|K]|$H|U|I|V|J|K]]|8|@]|9|$]]|$1|L|3|-4|4|5|6|W|7|@]|8|@]|9|$]]]|M|$]]

<blockquote>
 I've gotten double-checked locking to work by using a boolean (i.e. using a primitive to avoid the lazy initialisation):
</blockquote>

The singleton using boolean does not work. The order of operations as seen between different threads is not guaranteed unless you go through a memory barrier. 
In other words, as seen from a second thread, 
<code>created = true</code> may be executed before <code>instance= new Singleton();</code>

blocks|key|3370384|text|我不明白为什么所有人都说双重检查锁定是不好的模式，但却不调整代码以使其正确工作。在我看来，下面的代码应该可以很好地工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3370385|如果有人能告诉我这段代码是否存在卡梅隆文章中提到的问题，请告诉我。|3370386|public+sealed+class+Singleton+{
++++static+Singleton+instance+=+null;
++++static+readonly+object+padlock+=+new+object();

++++Singleton()+{
++++}

++++public+static+Singleton+Instance+{
++++++++get+{
++++++++++++if+(instance+!=+null)+{
++++++++++++++++return+instance;
++++++++++++}

++++++++++++lock+(padlock)+{
++++++++++++++++if+(instance+!=+null)+{
++++++++++++++++++++return+instance;
++++++++++++++++}

++++++++++++++++tempInstance+=+new+Singleton();

++++++++++++++++//+initialize+the+object+with+data

++++++++++++++++instance+=+tempInstance;
++++++++++++}
++++++++++++return+instance;
++++++++}
++++}
}|code-block|syntax|javascript|3370387|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I don't get why all people says that the double-check locking is bad pattern, but don't adapt the code to make it work correctly. In my opinion, this below code should work just fine. 

If someone could tell me if this code suffer from the problem mentionned in Cameron's article, please do.

<pre><code>public sealed class Singleton {
 static Singleton instance = null;
 static readonly object padlock = new object();

 Singleton() {
 }

 public static Singleton Instance {
 get {
 if (instance != null) {
 return instance;
 }

 lock (padlock) {
 if (instance != null) {
 return instance;
 }

 tempInstance = new Singleton();

 // initialize the object with data

 instance = tempInstance;
 }
 return instance;
 }
 }
}
</code></pre>

blocks|key|938569|text|我不太理解为什么会有一堆关于双重检查锁定的实现模式(显然是为了绕过各种语言中的编译器特性)。维基百科关于这个主题的文章展示了解决问题的简单方法和可能的方法，但没有一个像这样简单(在C#中)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|938570|public+class+Foo
{
++static+Foo+_singleton+=+null;
++static+object+_singletonLock+=+new+object();

++public+static+Foo+Singleton
++{
++++get
++++{
++++++if+(+_singleton+==+null+)
++++++++lock+(+_singletonLock+)
++++++++++if+(+_singleton+==+null+)
++++++++++{
++++++++++++Foo+foo+=+new+Foo();

++++++++++++//+Do+possibly+lengthy+initialization,
++++++++++++//+but+make+sure+the+initialization
++++++++++++//+chain+doesn't+invoke+Foo.Singleton.
++++++++++++foo.Initialize();

++++++++++++//+_singleton+remains+null+until
++++++++++++//+object+construction+is+done.
++++++++++++_singleton+=+foo;
++++++++++}
++++++return+_singleton;
++++}
++}|code-block|syntax|javascript|938571|在Java中，您将使用synchronized()而不是lock()，但这基本上是相同的概念。如果单例字段的赋值时间可能不一致，那么为什么不先使用局部作用域变量，然后在退出临界区之前的最后时刻赋值单例字段呢？我是不是遗漏了什么？|938572|@michael-borgwardt的论点是，在C#和Java中，静态字段只在第一次使用时初始化一次，但认为行为是特定于语言的。我经常使用这个模式来延迟初始化一个集合属性(例如user.Sessions)。|offset|length|style|BOLD|938573|entityMap^0|0|0|0|1G|2|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I don't quite understand why there are a bunch of implementation patterns on double-checked locking (apparently to work around compiler idiosyncrasies in various languages). The Wikipedia article on this topic shows the naive method and the possible ways to solve the problem, but none are as simple as this (in C#):

<pre><code>public class Foo
{
 static Foo _singleton = null;
 static object _singletonLock = new object();

 public static Foo Singleton
 {
 get
 {
 if ( _singleton == null )
 lock ( _singletonLock )
 if ( _singleton == null )
 {
 Foo foo = new Foo();

 // Do possibly lengthy initialization,
 // but make sure the initialization
 // chain doesn't invoke Foo.Singleton.
 foo.Initialize();

 // _singleton remains null until
 // object construction is done.
 _singleton = foo;
 }
 return _singleton;
 }
 }
</code></pre>

In Java, you'd use synchronized() instead of lock(), but it's basically the same idea. If there's the possible inconsistency of when the singleton field gets assigned, then why not just use a locally scoped variable first and then assign the singleton field at the last possible moment before exiting the critical section? Am I missing something?

There's the argument by @michael-borgwardt that in C# and Java the static field only gets initialized once on first use, but that behavior is language specific. And I've used this pattern frequently for lazy initialization of a collection property (e.g. user.Sessions).

blocks|key|4216516|text|通过使用布尔值(即使用原语来避免惰性初始化)，我获得了双重检查锁定：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4216517|private+static+Singleton+instance;
private+static+boolean+created;
public+static+Singleton+getInstance()+{
++++if+(!created)+{
++++++++synchronized+(Singleton.class)+{
++++++++++++if+(!created)+{
++++++++++++++++instance+=+new+Singleton();
++++++++++++++++created+=+true;
++++++++++++}
++++++++}
++++}
++++return+instance;
}|code-block|syntax|javascript|4216518|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|$]]

I've gotten double-checked locking to work by using a boolean (i.e. using a primitive to avoid the lazy initialisation):

<pre><code>private static Singleton instance;
private static boolean created;
public static Singleton getInstance() {
 if (!created) {
 synchronized (Singleton.class) {
 if (!created) {
 instance = new Singleton();
 created = true;
 }
 }
 }
 return instance;
}
</code></pre>

I came across <a href="http://www.cs.umd.edu/%7Epugh/java/memoryModel/DoubleCheckedLocking.html" rel="nofollow noreferrer">this</a> article discussing why the double-check locking paradigm is broken in Java. Is the paradigm valid for .NET (in particular, C#), if variables are declared <code>volatile</code>?

Double-checked locking in .NET

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

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

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

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

社区新版编辑器体验调研

我偶然看到的一篇文章，讨论为什么双重检查锁定范例在Java语言中被打破了。如果变量被声明为volatile，那么该范例对于.NET (特别是C#)是否有效

问.NET中的双重检查锁定
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET中的双重检查锁定EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问.NET中的双重检查锁定
EN