当前位置：首页 > news >正文

网站使用费用网页升级访问更新中

news 2025/10/2 20:24:55

网站使用费用,网页升级访问更新中,wordpress电脑微信登陆不了,网页游戏排行榜2014年单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点来获取该实例。以下是详细介绍单例模式的各种实现方式。 1. 饿汉式单例模式代码示例 using System;// 饿汉式单例类 public sealed class EagerSingleton {// 静态只读字段…

单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点来获取该实例。以下是详细介绍单例模式的各种实现方式。

1. 饿汉式单例模式

代码示例

using System;// 饿汉式单例类
public sealed class EagerSingleton
{// 静态只读字段，在类加载时就初始化实例private static readonly EagerSingleton instance = new EagerSingleton();// 私有构造函数，防止外部实例化private EagerSingleton(){Console.WriteLine("EagerSingleton 实例已创建");}// 公共静态属性，用于获取单例实例public static EagerSingleton Instance{get{return instance;}}// 示例方法public void DoSomething(){Console.WriteLine("EagerSingleton 正在执行操作");}
}class Program
{static void Main(){// 获取单例实例EagerSingleton singleton = EagerSingleton.Instance;// 调用示例方法singleton.DoSomething();}
}

案例解读

类加载与实例创建：在 C# 中，当一个类被加载时，其静态成员会被初始化。这里的 private static readonly EagerSingleton instance = new EagerSingleton(); 使得 EagerSingleton 类在加载时就创建了唯一的实例。readonly 关键字保证了这个实例一旦被创建，就不能被重新赋值。
私有构造函数：private EagerSingleton() 阻止了外部代码通过 new 关键字创建新的 EagerSingleton 实例，确保了单例的唯一性。
公共静态属性：public static EagerSingleton Instance 提供了一个全局访问点，外部代码可以通过 EagerSingleton.Instance 来获取这个唯一的实例。

优缺点分析

优点：实现简单，线程安全。由于实例在类加载时就创建好了，不存在多线程同时创建实例的问题。
缺点：可能会造成资源浪费。如果这个单例实例在整个应用程序的生命周期中都没有被使用，那么它仍然会在类加载时被创建，占用系统资源。

2. 懒汉式单例模式（非线程安全）

代码示例

using System;// 懒汉式单例类（非线程安全）
public sealed class LazySingletonNonThreadSafe
{// 静态字段，初始为 nullprivate static LazySingletonNonThreadSafe instance;// 私有构造函数，防止外部实例化private LazySingletonNonThreadSafe(){Console.WriteLine("LazySingletonNonThreadSafe 实例已创建");}// 公共静态属性，用于获取单例实例public static LazySingletonNonThreadSafe Instance{get{if (instance == null){instance = new LazySingletonNonThreadSafe();}return instance;}}// 示例方法public void DoSomething(){Console.WriteLine("LazySingletonNonThreadSafe 正在执行操作");}
}class Program
{static void Main(){// 获取单例实例LazySingletonNonThreadSafe singleton = LazySingletonNonThreadSafe.Instance;// 调用示例方法singleton.DoSomething();}
}

案例解读

延迟实例化：private static LazySingletonNonThreadSafe instance; 初始化为 null，在第一次调用 Instance 属性时，通过 if (instance == null) 判断实例是否已经创建，如果未创建则创建新实例。这种方式实现了延迟加载，只有在需要使用实例时才会创建。
非线程安全问题：在多线程环境下，可能会有多个线程同时进入 if (instance == null) 这个判断语句，从而导致多个线程都创建了新的实例，破坏了单例的唯一性。

优缺点分析

优点：实现了延迟加载，避免了不必要的资源浪费。
缺点：非线程安全，在多线程环境下不能保证单例的唯一性。

3. 懒汉式单例模式（线程安全，简单加锁）

代码示例

using System;// 懒汉式单例类（线程安全，简单加锁）
public sealed class LazySingletonThreadSafeSimple
{// 静态字段，初始为 nullprivate static LazySingletonThreadSafeSimple instance;// 静态对象，用于加锁private static readonly object lockObject = new object();// 私有构造函数，防止外部实例化private LazySingletonThreadSafeSimple(){Console.WriteLine("LazySingletonThreadSafeSimple 实例已创建");}// 公共静态属性，用于获取单例实例public static LazySingletonThreadSafeSimple Instance{get{lock (lockObject){if (instance == null){instance = new LazySingletonThreadSafeSimple();}}return instance;}}// 示例方法public void DoSomething(){Console.WriteLine("LazySingletonThreadSafeSimple 正在执行操作");}
}class Program
{static void Main(){// 获取单例实例LazySingletonThreadSafeSimple singleton = LazySingletonThreadSafeSimple.Instance;// 调用示例方法singleton.DoSomething();}
}

案例解读

加锁机制：private static readonly object lockObject = new object(); 创建了一个静态的锁对象。在 Instance 属性的 get 方法中，使用 lock (lockObject) 对代码块进行加锁，确保同一时间只有一个线程能进入这个代码块。
线程安全实现：通过加锁，当一个线程进入 lock 代码块时，其他线程会被阻塞，直到该线程完成实例的创建。这样就保证了在多线程环境下实例只会被创建一次。

优缺点分析

优点：实现了线程安全，保证了单例的唯一性。
缺点：每次获取实例都需要加锁，加锁操作会带来一定的性能开销。即使实例已经创建好了，后续的线程访问仍然需要进行加锁操作，这在高并发场景下会影响性能。

4. 双重检查锁定单例模式（线程安全）

代码示例

using System;// 双重检查锁定单例类
public sealed class DoubleCheckedLockingSingleton
{// 静态字段，初始为 nullprivate static DoubleCheckedLockingSingleton instance;// 静态对象，用于加锁private static readonly object lockObject = new object();// 私有构造函数，防止外部实例化private DoubleCheckedLockingSingleton(){Console.WriteLine("DoubleCheckedLockingSingleton 实例已创建");}// 公共静态属性，用于获取单例实例public static DoubleCheckedLockingSingleton Instance{get{if (instance == null){lock (lockObject){if (instance == null){instance = new DoubleCheckedLockingSingleton();}}}return instance;}}// 示例方法public void DoSomething(){Console.WriteLine("DoubleCheckedLockingSingleton 正在执行操作");}
}class Program
{static void Main(){// 获取单例实例DoubleCheckedLockingSingleton singleton = DoubleCheckedLockingSingleton.Instance;// 调用示例方法singleton.DoSomething();}
}

案例解读

第一次检查：if (instance == null) 在加锁前先进行检查，如果实例已经创建好了，就直接返回实例，避免了不必要的加锁操作，提高了性能。
加锁与第二次检查：如果第一次检查发现实例为 null，则进入 lock (lockObject) 代码块进行加锁。在加锁后，再次进行 if (instance == null) 检查，防止多个线程同时通过第一次检查，在一个线程创建实例后，其他线程不会再重复创建。

优缺点分析

优点：既实现了延迟加载，又保证了线程安全，同时减少了不必要的锁操作，提高了性能。
缺点：实现相对复杂，需要对多线程编程有一定的理解。

5. 使用 `Lazy<T>` 实现单例模式（线程安全）

代码示例

using System;// 使用 Lazy<T> 实现的单例类
public sealed class LazyGenericSingleton
{// 静态只读的 Lazy<T> 实例private static readonly Lazy<LazyGenericSingleton> lazy = new Lazy<LazyGenericSingleton>(() => new LazyGenericSingleton());// 私有构造函数，防止外部实例化private LazyGenericSingleton(){Console.WriteLine("LazyGenericSingleton 实例已创建");}// 公共静态属性，用于获取单例实例public static LazyGenericSingleton Instance{get{return lazy.Value;}}// 示例方法public void DoSomething(){Console.WriteLine("LazyGenericSingleton 正在执行操作");}
}class Program
{static void Main(){// 获取单例实例LazyGenericSingleton singleton = LazyGenericSingleton.Instance;// 调用示例方法singleton.DoSomething();}
}

案例解读

Lazy<T> 类的使用：private static readonly Lazy<LazyGenericSingleton> lazy = new Lazy<LazyGenericSingleton>(() => new LazyGenericSingleton()); 创建了一个 Lazy<T> 实例，使用委托 () => new LazyGenericSingleton() 指定了实例的创建方式。
延迟加载与线程安全：Lazy<T> 类会在第一次访问 lazy.Value 时才创建实例，实现了延迟加载。同时，Lazy<T> 类内部处理了线程安全问题，确保实例只被创建一次。

优缺点分析

优点：实现简单，代码简洁，同时保证了延迟加载和线程安全。
缺点：依赖于 .NET 框架的 Lazy<T> 类，如果需要在不支持该类的环境中使用，就无法采用这种实现方式。

6. 静态内部类实现单例模式（线程安全）

代码示例

using System;// 静态内部类实现的单例类
public sealed class StaticNestedClassSingleton
{// 私有构造函数，防止外部实例化private StaticNestedClassSingleton(){Console.WriteLine("StaticNestedClassSingleton 实例已创建");}// 静态内部类private static class Nested{// 静态只读字段，保存单例实例internal static readonly StaticNestedClassSingleton Instance = new StaticNestedClassSingleton();}// 公共静态属性，用于获取单例实例public static StaticNestedClassSingleton Instance{get{return Nested.Instance;}}// 示例方法public void DoSomething(){Console.WriteLine("StaticNestedClassSingleton 正在执行操作");}
}class Program
{static void Main(){// 获取单例实例StaticNestedClassSingleton singleton = StaticNestedClassSingleton.Instance;// 调用示例方法singleton.DoSomething();}
}

案例解读

静态内部类的特性：在 C# 中，静态内部类只会在第一次被使用时加载。private static class Nested 是一个静态内部类，其中的 internal static readonly StaticNestedClassSingleton Instance = new StaticNestedClassSingleton(); 在类加载时创建了 StaticNestedClassSingleton 的实例。
延迟加载与线程安全：当第一次访问 StaticNestedClassSingleton.Instance 时，会触发 Nested 类的加载，从而创建单例实例。由于静态类的加载是线程安全的，所以这种方式实现了延迟加载和线程安全。

优缺点分析

优点：实现简单，代码简洁，同时保证了延迟加载和线程安全。
缺点：对于不熟悉静态内部类特性的开发者来说，可能不太容易理解。

7. 通过 `Mutex` 实现单例模式（系统级单例）

代码示例

using System;
using System.Threading;// 通过 Mutex 实现的单例类
public sealed class MutexSingleton
{// 静态字段，保存单例实例private static MutexSingleton instance;// 静态 Mutex 实例private static readonly Mutex mutex = new Mutex(true, "MutexSingleton");// 私有构造函数，防止外部实例化private MutexSingleton(){Console.WriteLine("MutexSingleton 实例已创建");}// 公共静态属性，用于获取单例实例public static MutexSingleton Instance{get{if (instance == null){mutex.WaitOne();try{if (instance == null){instance = new MutexSingleton();}}finally{mutex.ReleaseMutex();}}return instance;}}// 示例方法public void DoSomething(){Console.WriteLine("MutexSingleton 正在执行操作");}
}class Program
{static void Main(){// 获取单例实例MutexSingleton singleton = MutexSingleton.Instance;// 调用示例方法singleton.DoSomething();}
}

案例解读

Mutex 的使用：private static readonly Mutex mutex = new Mutex(true, "MutexSingleton"); 创建了一个命名的 Mutex 实例，true 表示创建线程拥有互斥体的初始所有权，"MutexSingleton" 是互斥体的名称，确保在整个系统中具有唯一性。
线程同步与实例创建：在 Instance 属性的 get 方法中，mutex.WaitOne() 等待获取互斥量，如果获取到则进入临界区。在临界区内，再次检查实例是否为 null，如果为 null 则创建实例。最后，使用 mutex.ReleaseMutex() 释放互斥量，允许其他线程或进程获取该互斥量。