关于c＃：以单例模式双重检查锁定

double check locking in singleton pattern

这可能是个基本问题

要在多线程环境中使用单实例，我们可以使用锁。请参考代码段。但是为什么我们需要单例模式中的双重检查锁定？还有，双重检查锁定意味着什么？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class singleton
{
private static singleton instance = null;
private static singleton() { }

private static object objectlock = new object();

public static singleton Instance
{
get
{

lock (objectlock) //single - check lock
{
if (instance == null)
{
instance = new singleton();
}

return instance;
}
}

}
}

相关讨论

对于.NET 4.x及更高版本，您应该尽可能地遵从lazy类，因为此模式与初始化和发布选项一起使用。(注意：如果创建不是线程安全的，但实例的发布是通过发布选项发布的，则可以使用反向函数)

多线程单线程：使用双重检查锁定的最佳方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public sealed class Singleton
{
private static volatile Singleton _instance;
private static readonly object InstanceLoker= new Object();

private Singleton() {}

public static Singleton Instance
{
get
{
if (_instance == null)
{
lock (InstanceLoker)
{
if (_instance == null)
_instance = new Singleton();
}
}

return _instance;
}
}
}

我知道"最好"的方法是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public class MySingleton {
// object for synchronization
private static readonly object syncRoot = new object();
// the singleton instance
private static MySingleton @default;

public static MySingleton Default {
get {
// geting singleton instance without locking
var result = @default;
// if result is NOT null, no additional action is required
if ( object.ReferenceEquals(result, null) ){
// lock the synchronization object
lock(syncRoot) {
// geting singleton instanc in lock - because
// the value of @default field could be changed
result = @default;

// checking for NULL
if ( object.ReferenceEquals(result, null) ) {
// if result is NULL, create new singleton instance
result = new MySingleton();
// set the default instance
@default = result;
}
}
}

// return singleton instance
return result;
}
}
}