C#单例模式设计实例

所谓的单例模式就是在整个程序的生命周期中，只创建一个实例。

要实现这种模式可以采用饿汉模式，饱汉模式，双重锁模式和懒加载模式。

什么是饿汉模式呢？

饿汉模式就是很饿很着急，所以类加载时即创建实例对象。在这种情况下无需担心多线程下实例被

多次创建的问题，但是如果有一些实例对象我们是不需要的那么问题就来了，使用过多的话就会造

程启动慢的问题；

说了这么多那么我们又该如何创建这样的一个单例模式呢？

public class Hungry
{
	private static readonly Hungry  _Hungry=new Hungry();
	private Hungry(){}
	public static Hungry getInstance(){
		return _Hungry;
	}//直接返回对象引用
}

有饿汉那么想必就有饱汉。

饱了，所以并不着急产生实例化对象，需要的时候再产生，毕竟需要吃点小吃的时候再去吃东西嘛。

这么随意真的好吗？那么问题来了在需要的时候就产生实例化对象，这样的话线程就变得不安全了，

这样得话在产生实例化对象的时候就要判断对象的引用是否为空，如果我们使用多个线程同时判断

的话那岂不是很美好，然而这样还是单例模式吗？那如何解决这个问题呢？

public class Satiation
{
 private static Satiation _Satiation;
 private Satiation(){}
 public static synchronized Satiation getInstance(){
	 if(_Satiation==null)
		 _Satiation=new Satiation();
	 return Satiation;
    } 
}

为了保护线程安全，使用synchronized关键字标识了方法。但是在这种模式中效率就会有所牺牲，因为

需要保证同步。

人类的智慧是无限的，牺牲效率？于是乎为了提高饱汉模式的效率，那么就创造除了双重锁模式，这种模式

是对饱汗模式的一种优化，进行双重判断，当已经创建过实例化对象后就无需加锁，提高效率。

public class Satiation_g
{
	private static Satiation_g _Satiation;
	private Satiation_g(){}
	
	
}
public static Satiation_g getInstance()
{
	if(_Satiation==null)
	{
		synchronized(Satiation_g.class)
		{
			if(_Satiation==null)
			{
				_Satiation=new Satiation_g();
			}
		}
		return _Satiation;
	}
	
}

最后一个就是懒加载模式了，此模式使用lock(SynObjiect)用于保证代码运行到该处时阻止另一个进程访问后面的代码，

直到当前进程运行完成，主要是阻止多个进程同时访问_lazy。

public class lazy
{
    private static lazy _lazy= null;
    private static readonly object SynObject = new object();


    private lazy() { }
       
    public static lazy getInstance()
    {
        if (_lazy == null)
        {
           lock (SynObject)
           {
                if (_lazy == null)
                {
                    _lazy = new lazy();
                }
           }
        }


        return _lazy;
    }
}

C#单例模式设计实例

猜你喜欢