聊聊如何使用单例模式

开发 前端
单例模式,顾名思义就是只有一个实例,并且她自己负责创建自己的对象,这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。下面我们来看下有哪几种实现方式吧。

[[381341]]

本文转载自微信公众号「UP技术控」,作者conan5566。转载本文请联系UP技术控公众号。

介绍

单例模式,顾名思义就是只有一个实例,并且她自己负责创建自己的对象,这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。下面我们来看下有哪几种实现方式吧。

实现方式

1、使用lock ,保证方法只有一个线程可以进入。

 

 

  1. /// <summary> 
  2.     /// 单例类 
  3.     /// </summary> 
  4.     public class Singleton 
  5.     { 
  6.         private Singleton() 
  7.         { 
  8.             long lResult = 0; 
  9.             for (int i = 0; i < 100 - 000 - 000; i++) 
  10.             { 
  11.                 lResult += i; 
  12.             } 
  13.             Thread.Sleep(2000); 
  14.             Console.WriteLine($"{this.GetType().Name}完成构造...."); 
  15.         } 
  16.         private static Singleton Instance = null
  17.         private static readonly object Singleton_Lock = new object(); 
  18.         public static Singleton CreateInstance() 
  19.         { 
  20.             if (Instance == null
  21.             { 
  22.                 lock (Singleton_Lock)//保证方法块儿只有一个线程可以进入 
  23.                 { 
  24.                     Console.WriteLine("进入lock排队...."); 
  25.                     Thread.Sleep(1000); 
  26.                     if (Instance == null
  27.                         Instance = new Singleton(); 
  28.                 } 
  29.             } 
  30.             return Instance; 
  31.         } 
  32.  
  33.         public static void DoNothing() 
  34.         { 
  35.             Console.WriteLine("DoNothing"); 
  36.         } 
  37.  
  38.         public void Show() 
  39.         { 
  40.             Console.WriteLine($"{this.GetType().Name} Show...."); 
  41.         } 
  42.     } 

2、使用静态构造函数,由CLR调用,在类型第一次被使用前调用,且只调用一次。

 

 

  1. /// <summary> 
  2.     /// 单例类 
  3.     /// </summary> 
  4.     public class SingletonSecond 
  5.     { 
  6.         private SingletonSecond() 
  7.         { 
  8.             long lResult = 0; 
  9.             for (int i = 0; i < 100 - 000 - 000; i++) 
  10.             { 
  11.                 lResult += i; 
  12.             } 
  13.             Thread.Sleep(2000); 
  14.             Console.WriteLine($"{this.GetType().Name}完成构造...."); 
  15.         } 
  16.         private static SingletonSecond Instance = null
  17.         /// <summary> 
  18.         /// 静态构造函数,由CLR调用,在类型第一次被使用前调用,且只调用一次! 
  19.         /// </summary> 
  20.         static SingletonSecond() 
  21.         { 
  22.             Instance = new SingletonSecond(); 
  23.         } 
  24.         public static SingletonSecond CreateInstance() 
  25.         { 
  26.              
  27.             return Instance; 
  28.         } 
  29.  
  30.         public static void DoNothing() 
  31.         { 
  32.             Console.WriteLine("DoNothing"); 
  33.         } 
  34.  
  35.         public void Show() 
  36.         { 
  37.             Console.WriteLine($"{this.GetType().Name} Show...."); 
  38.         } 
  39.     } 

3、使用静态字段,由CLR调用,在类型第一次被使用前初始化,且只初始化一次。

 

 

  1. /// <summary> 
  2.     /// 单例类 
  3.     /// </summary> 
  4.     public class SingletonThird 
  5.     { 
  6.         private SingletonThird() 
  7.         { 
  8.             long lResult = 0; 
  9.             for (int i = 0; i < 100 - 000 - 000; i++) 
  10.             { 
  11.                 lResult += i; 
  12.             } 
  13.             Thread.Sleep(2000); 
  14.             Console.WriteLine($"{this.GetType().Name}完成构造...."); 
  15.         } 
  16.         /// <summary> 
  17.         /// 静态字段,由CLR调用,在类型第一次被使用前初始化,且只初始化一次! 
  18.         /// </summary> 
  19.         private static SingletonThird Instance = new SingletonThird(); 
  20.         
  21.         public static SingletonThird CreateInstance() 
  22.         { 
  23.              
  24.             return Instance; 
  25.         } 
  26.  
  27.         public static void DoNothing() 
  28.         { 
  29.             Console.WriteLine("DoNothing"); 
  30.         } 
  31.  
  32.         public int iNum = 0; 
  33.         public void Show() 
  34.         { 
  35.             Console.WriteLine($"{this.GetType().Name} Show..{iNum++}.."); 
  36.         } 
  37.  
  38.         public void Add() 
  39.         { 
  40.             this.iNum++; 
  41.         } 
  42.     } 

使用场景

1、需要生成唯一序列的环境。

2、需要频繁实例化然后销毁的对象。

3、创建对象时耗时过多或者耗资源过多,但又经常用到的对象。

4、方便资源相互通信的环境。

 

责任编辑:武晓燕 来源: UP技术控
相关推荐

2023-11-21 21:39:38

单例模式音频管理器

2021-03-02 08:50:31

设计单例模式

2023-07-31 12:27:30

单例设计模式

2021-02-01 10:01:58

设计模式 Java单例模式

2022-09-29 08:39:37

架构

2013-11-26 16:20:26

Android设计模式

2016-03-28 10:23:11

Android设计单例

2021-09-07 10:44:35

异步单例模式

2022-06-07 08:55:04

Golang单例模式语言

2011-03-16 10:13:31

java单例模式

2022-02-06 22:30:36

前端设计模式

2010-01-27 10:45:21

C++单例模式

2024-03-06 13:19:19

工厂模式Python函数

2024-02-04 12:04:17

2016-10-09 09:37:49

javascript单例模式

2015-09-06 11:07:52

C++设计模式单例模式

2011-06-28 15:18:45

Qt 单例模式

2022-05-23 07:35:15

单例模式懒汉模式静态内部类

2010-02-05 17:00:06

C++单例模式

2020-09-16 12:18:28

GoJava模式
点赞
收藏

51CTO技术栈公众号