当前位置:澳门新葡亰网站所有平台 > www.7415.com > 单例模式

单例模式

文章作者:www.7415.com 上传时间:2019-09-10

资料借鉴:

简单介绍:

  单例模式是一种经常用到的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中应用该模式的类只有一个实例。即一个类只有一个实例

定义:

  一个类有且只有一个实例,并且自行实例化向整个系统提供。

特点:

       1、单例类只能有一个实例。

  2、单例类必须自己创建自己的唯一实例。

  3、单例类必须给所有其他对象提供这一实例。

实现方式:

  一般来说,我们有以下几个必要的操作:

    1、私有化构造方法;

    2、final类(定义为不可继承,这点书上没有提到,暂时还在研究)

    3、将类的实例对象定义为一个私有的属性(不限制为成员变量)

    4、通过getInstance()方法获取实例,若私有的实例属性对象引用不为空则返回,否则实例化该属性并返回

  这里先介绍四种实现方式

      1、饿汉模式

    2、懒汉模式

    3、双重验证

    4、静态内部类模式

 

先看第一种方式,饿汉模式顾名思义,迫不及待的想要吃(初始化实例),在类中定义一个私有静态本类的实例化对象,在类加载的过程就进行此对象的实例化,之后的对此类实例的调用都是调用此实例。

代码如下:

public class Singleton2 {

    private static Singleton2 singleton2= new Singleton2();

    private Singleton2(){}

    public static Singleton2 getInstance() {
        return singleton2;
    }

    public static String getStr() {
        return "Create String type Object";
    }
}

饿汉模式是较为简单的实现方式,同样也是较为常用的方式。但他有着一定的缺陷:虽然在单例模式中大多都只调用getInstance()方法,但不排除有其他的方式导致类加载,比如如果类中getStr()这种与类的实例无关的方法如果被调用,就会触发类加载,从而对静态成员进行初始化,但是此类有可能并不需要实例化,这样在某种程度上会造成一定的资源浪费。也就无法达到lazy loading的效果。

 

这就引入了懒汉模式

www.7415.com, 

懒汉模式:只有在第一此调用类的实例对象时才会初始化类的实例,从而实现延迟加载

代码如下

public class Singleton3 {

    private static Singleton3 singleton2 = null;

    private Singleton3(){
        Tools.println("类实例化");
    }

    public static synchronized Singleton3 getInstance(){
        if(singleton2 == null)
            singleton2 = new Singleton3();
        return singleton2;
    }

    public static void CreateString(){
        Tools.print("Create String in Singleton3");
    }
}

懒汉模式通过getInstance()方法创建实例,这样只有在使用到实例的时候才会初始化实例对象,实现了延迟加载,但是这种模式会出现线程同步问题:一个线程调用了getInstace()方法,判断为空后进行实例的创建,此时又有了一个线程调用了getInstance()方法,但此刻第一个线程还没有完成实例化的操作,故此线程也会实例化一个对象。所以我们需要为getInstance()方法加上同步关键字synchronized 。

那么问题来了,我们使用延迟加载就是为了提升系统性能,而引入了同步关键字则会大大影响多线程情况下的性能,所以此方式也有这很大的缺陷。

 

下面就引入了双重检测方式

 

双重检测方式:通过双重检测的方式完成延迟加载

代码如下:

class Singleton1 {

    private Singleton1() {
    }

    public static Singleton1 instance = null;

    public static Singleton1 getInstance() {
        if (instance == null) {
            synchronized (Singleton1.class) {
                if (instance == null) {
                    instance = new Singleton1();
                }
            }
        }
        return instance;
    }
}

可以看到,首先判断实例对象是否为空,如果判断通过再进行同步操作。

这种方式是解决了懒汉模式的效率问题,但同时也有一些问题,第一次加载时反应不快,由于java内存模型一些原因偶尔失败。失败原因可以详见

 

接下来引入一种已经较为完善并且使用较多的一种实现方式:静态内部类实现

代码如下:

public class Singleton4 {

private Singleton4(){}

static class SingletonHolder {

private static Singleton4 singleton = new Singleton4();

}

public static Singleton4 getInstance(){

return SingletonHolder.singleton;

}

}

此方式利用了:静态内部类并不会在外部类类加载的时候也进行类加载,而是在它自身第一次被使用时进行类加载,并且jvm的类加载过程是对线程非常友好的,所以我们不需要担心同步问题。

public class Singleton4 {

    private Singleton4(){}

    static class SingletonHolder {
        private static Singleton4 singleton = new Singleton4();
    }

    public static Singleton4 getInstance(){
        return SingletonHolder.singleton;
    }
}

 

上述方法都是基本上实现了单例模式,但是依然有两个问题需要注意:

1:如果单例由不同的类装载器注入,那边有可能存在有多个单例类的实例。假如不是远端存取,假如一些servlet容器对每个servlet使用不同的类装载器,他们就会有个字的单例类的实例。

2:如果单例类实现了java.io.Serializable接口,那么此类的实例就可以被序列化和复原,如果序列化一个对象,然后复原多个此对象,就会出现多个单例类的实例。

关于此问题可以参照此文章:

 

第一个问题的解决方法:

private static Class getClass(String classname)      
                                         throws ClassNotFoundException {     
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();     

      if(classLoader == null)     
         classLoader = Singleton.class.getClassLoader();     

      return (classLoader.loadClass(classname));     
   }     
}

第二个问题的解决方法:

public class Singleton implements java.io.Serializable {     
   public static Singleton INSTANCE = new Singleton();     

   protected Singleton() {     

   }     
   private Object readResolve() {     
            return INSTANCE;     
      }    
}  

 

这两种方法是我从其他的博客上看来的,现在还在了解中。。。

 

 

应用场景:

  1. Windows的Task Manager(任务管理器)就是很典型的单例模式(这个很熟悉吧),想想看,是不是呢,你能打开两个windows task manager吗? 不信你自己试试看哦~ 

  2. windows的Recycle Bin(回收站)也是典型的单例应用。在整个系统运行过程中,回收站一直维护着仅有的一个实例。

  3. 网站的计数器,一般也是采用单例模式实现,否则难以同步。

4. 应用程序的日志应用,一般都何用单例模式实现,这一般是由于共享的日志文件一直处于打开状态,因为只能有一个实例去操作,否则内容不好追加。

5. Web应用的配置对象的读取,一般也应用单例模式,这个是由于配置文件是共享的资源。

6. 数据库连接池的设计一般也是采用单例模式,因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池,主要是节省打开或者关闭数据库连接所引起的效率损耗,这种效率上的损耗还是非常昂贵的,因为何用单例模式来维护,就可以大大降低这种损耗。

7. 多线程的线程池的设计一般也是采用单例模式,这是由于线程池要方便对池中的线程进行控制。

8. 操作系统的文件系统,也是大的单例模式实现的具体例子,一个操作系统只能有一个文件系统。

9. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式,所有的HttpModule都共享一个HttpApplication实例.

 

总结以上,不难看出:

  单例模式应用的场景一般发现在以下条件下:

  (1)资源共享的情况下,避免由于资源操作时导致的性能或损耗等。如上述中的日志文件,应用配置。

  (2)控制资源的情况下,方便资源之间的互相通信。如线程池等。

本文由澳门新葡亰网站所有平台发布于www.7415.com,转载请注明出处:单例模式

关键词: