版权声明:本文为博主原创文章,转载请注明出处谢谢 https://blog.csdn.net/CALL_LKC/article/details/79735624
所谓的单例模式就是在整个程序的生命周期中,只创建一个实例。
要实现这种模式可以采用饿汉模式,饱汉模式,双重锁模式和懒加载模式。
什么是饿汉模式呢?
饿汉模式就是很饿很着急,所以类加载时即创建实例对象。在这种情况下无需担心多线程下实例被
多次创建的问题,但是如果有一些实例对象我们是不需要的那么问题就来了,使用过多的话就会造
程启动慢的问题;
说了这么多那么我们又该如何创建这样的一个单例模式呢?
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;
}
}