设计模式(1)——单例模式

来源：互联网发布：电脑游戏录像软件编辑：程序博客网时间：2024/05/12 03:39

原文地址：http://blog.jobbole.com/78059/

单例模式也就是保证一个类只有一个实例的一种实现方法；

应用场景：

单例模式的使用自然是当我们的系统中某个对象只需要一个实例的情况，例如:操作系统中只能有一个任务管理器,操作文件时,同一时间内只允许一个实例对其操作等,既然现实生活中有这样的应用场景；

实现方式：

类定义私有的构造函数（就不能在外界通过new创建实例了）来确保一个类只有一个实例；定义静态私有变量保存此实例（每个线程都有自己的线程栈，定义为静态主要是为了在多线程确保类有一个实例）

/// <summary>
    /// 单例模式的实现
    /// </summary>
    publicclass Singleton
    {
        // 定义一个静态变量来保存类的实例
        privatestatic Singleton uniqueInstance;
 
        // 定义私有构造函数，使外界不能创建该类实例
        privateSingleton()
        {
        }
 
        /// <summary>
        /// 定义公有方法提供一个全局访问点,同时你也可以定义公有属性来提供全局访问点
        /// </summary>
        /// <returns></returns>
        publicstatic Singleton GetInstance()
        {
            // 如果类的实例不存在则创建，否则直接返回
            if(uniqueInstance == null)
            {
                uniqueInstance = newSingleton();
            }
            returnuniqueInstance;
        }
    }

上面的单例模式的实现在单线程下确实是完美的,然而在多线程的情况下会得到多个Singleton实例,因为在两个线程同时运行GetInstance方法时，此时两个线程判断(uniqueInstance ==null)这个条件时都返回真，此时两个线程就都会创建Singleton的实例，这样就违背了我们单例模式初衷了，既然上面的实现会运行多个线程执行，那我们对于多线程的解决方案自然就是使GetInstance方法在同一时间只运行一个线程运行就好了，也就是我们线程同步的问题了,具体的解决多线程的代码如下:

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
34
35
36
37
/// <summary>
    /// 单例模式的实现
    /// </summary>
    publicclass Singleton
    {
        // 定义一个静态变量来保存类的实例
        privatestatic Singleton uniqueInstance;
 
        // 定义一个标识确保线程同步
        privatestatic readonly object locker = newobject();
 
        // 定义私有构造函数，使外界不能创建该类实例
        privateSingleton()
        {
        }
 
        /// <summary>
        /// 定义公有方法提供一个全局访问点,同时你也可以定义公有属性来提供全局访问点
        /// </summary>
        /// <returns></returns>
        publicstatic Singleton GetInstance()
        {
            // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
            // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
            // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
            lock(locker)
            {
                // 如果类的实例不存在则创建，否则直接返回
                if(uniqueInstance == null)
                {
                    uniqueInstance = newSingleton();
                }
            }
 
            returnuniqueInstance;
        }
    }

上面这种解决方案确实可以解决多线程的问题,但是上面代码对于每个线程都会对线程辅助对象locker加锁之后再判断实例是否存在，对于这个操作完全没有必要的，因为当第一个线程创建了该类的实例之后，后面的线程此时只需要直接判断（uniqueInstance==null）为假，此时完全没必要对线程辅助对象加锁之后再去判断，所以上面的实现方式增加了额外的开销，损失了性能，为了改进上面实现方式的缺陷，我们只需要在lock语句前面加一句（uniqueInstance==null）的判断就可以避免锁所增加的额外开销，这种实现方式我们就叫它 “双重锁定”，下面具体看看实现代码的：

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
34
35
36
37
38
39
40
/// <summary>
    /// 单例模式的实现
    /// </summary>
    publicclass Singleton
    {
        // 定义一个静态变量来保存类的实例
        privatestatic Singleton uniqueInstance;
 
        // 定义一个标识确保线程同步
        privatestatic readonly object locker = newobject();
 
        // 定义私有构造函数，使外界不能创建该类实例
        privateSingleton()
        {
        }
 
        /// <summary>
        /// 定义公有方法提供一个全局访问点,同时你也可以定义公有属性来提供全局访问点
        /// </summary>
        /// <returns></returns>
        publicstatic Singleton GetInstance()
        {
            // 当第一个线程运行到这里时，此时会对locker对象 "加锁"，
            // 当第二个线程运行该方法时，首先检测到locker对象为"加锁"状态，该线程就会挂起等待第一个线程解锁
            // lock语句运行完之后（即线程运行完之后）会对该对象"解锁"
            // 双重锁定只需要一句判断就可以了
            if(uniqueInstance == null)
            {
                lock(locker)
                {
                    // 如果类的实例不存在则创建，否则直接返回
                    if(uniqueInstance == null)
                    {
                        uniqueInstance = newSingleton();
                    }
                }
            }
            returnuniqueInstance;
        }
    }

0 0