你的位置:首页 > ASP.net教程

[ASP.net教程]Singleton Pattern单例模式


单例模式是一种对象创建模式,它用于产生一个对象的具体实例,它可以确保系统中一个类只产生一个实例。Java里面实现的单例是一个虚拟机的范围,因为装载类的功能是虚拟机的,所以一个虚拟机在通过自己的 ClassLoad 装载实现单例类的时候就会创建一个类的实例。在 Java语言中,这样的行为能带来两大好处:

  1. 对于频繁使用的对象,可以省略创建对象所花费的时间,这对于那些重量级对象而言,是非常可观的一笔系统开销;

  2. 由于 new 操作的次数减少,因而对系统内存的使用频率也会降低,这将减轻 GC 压力,缩短 GC 停顿时间。

因此对于系统的关键组件和被频繁使用的对象,使用单例模式可以有效地改善系统的性能。单例模式的核心在于通过一个接口返回唯一的对象实例。首要的问题就是要把创建实例的权限收回来,让类自身来负责自己类的实例的创建工作,然后由这个类来提供外部可以访问这个类实例的方法

单例模式基本实现

/** * 单例模式基本实现 */public class Singleton {  // 首先单例模式必须要有一个private访问级别的构造函数,才能确保单例不会在系统中其他代码内被实例化,其次,instance 成员变量和  // getInstance 方法必须是 static 的。  private static Singleton instance = new Singleton();  private Singleton() {      }  public static Singleton getInstance() {    return instance;  }}

上述代码唯一的不足是无法对 instance 实例做延时加载,例如单例的创建过程很慢,而由于 instance 成员变量是 static 定义的,因此在 JVM加载单例类时,单例对象就会被建立,如果此时这个单例类在系统中还扮演其他角色,那么在任何使用这个单例类的地方都会初始化这个单例变量,而不管是否会被用到。

单例模式实验

public class Singleton {  private Singleton() {    System.out.println("Singleton is create");  }  private static Singleton instance = new Singleton();  public static Singleton getInsatnce() {    return instance;  }  public static void createString() {    System.out.println("createString in Singleton");  }  public static void main(String[] args) {    Singleton.createString();  }}

上述代码运行后的输出如

Singleton is createcreateString in Singleton

可以看到,虽然此时并没有使用单例类,但它还是被创建出来,为了解决这类问题,需要引入延迟加载机制。

//延迟加载的单例模式public class LazySingleton {  private LazySingleton() {    System.out.println("LazySingleton is create");  }  private static LazySingleton instance = null;  public static synchronized LazySingleton getInstance() {    if (instance == null) {      instance = new LazySingleton();    }    return instance;  }  public static void createString() {    System.out.println("create String");  }  public static void main(String[] args) {    LazySingleton.createString();  }}

上述代码运行后的输出如

create String

上述代码首先对于静态成员变量 instance 初始化赋值 null,确保系统启动时没有额外的负载;其次,在 getInstance()工厂方法中,判断当前单例是否已经存在,若存在则返回,不存在则再建立单例。这里尤其要注意的是,getInstance() 方法必须是同步的,否则在多线程环境下,当线程1正新建单例时,完成赋值操作前,线程2可能判断instance为null,故线程2也将启动新建单例的程序,而导致多个实例被创建,故同步关键字是必须的。由于引入了同步关键字,导致多线程环境下耗时明显增加,两者测试代码如下

非同步的单例模式代码

public class Singleton implements Runnable{  private Singleton() {    System.out.println("Singleton is create");  }  private static Singleton instance = new Singleton();  public static Singleton getInsatnce() {    return instance;  }  public static void createString() {    System.out.println("createString in Singleton");  }  public static void main(String[] args) {    //Singleton.createString();    for (int i = 0; i < 5; i++) {      new Thread(new Singleton()).start();    }  }  @Override  public void run() {    long beginTime=System.currentTimeMillis();    for (int i = 0; i < 100000000; i++) {      Singleton.getInsatnce();    }    System.out.println(System.currentTimeMillis()-beginTime);  }}

代码运行后输出

Singleton is createSingleton is createSingleton is createSingleton is createSingleton is createSingleton is create10120

完整的延迟加载方式代码

public class LazySingleton implements Runnable{  private LazySingleton() {    System.out.println("LazySingleton is create");  }  private static LazySingleton instance = null;  public static synchronized LazySingleton getInstance() {    if (instance == null) {      instance = new LazySingleton();    }    return instance;  }  public static void createString() {    System.out.println("create String");  }  public static void main(String[] args) {    //LazySingleton.createString();    for (int i = 0; i < 5; i++) {      new Thread(new LazySingleton()).start();    }    }  @Override  public void run() {    long beginTime=System.currentTimeMillis();    for (int i = 0; i < 100000000; i++) {      LazySingleton.getInstance();    }    System.out.println(System.currentTimeMillis()-beginTime);  }}

代码运行后输出

LazySingleton is createLazySingleton is createLazySingleton is createLazySingleton is createLazySingleton is createLazySingleton is create51255261527054405454

为了解决同步关键字降低系统性能的缺陷,做了一定改进

//延迟加载的单例模式public class LazySingleton implements Runnable{  private LazySingleton() {    System.out.println("LazySingleton is create");  }  private static LazySingleton instance = null;  public static LazySingleton getInstance() {    if (instance == null) {      synchronized (LazySingleton.class) {        if (instance == null) {          instance = new LazySingleton();        }      }    }    return instance;  }  public static void createString() {    System.out.println("create String");  }  public static void main(String[] args) {    for (int i = 0; i < 5; i++) {      new Thread(new LazySingleton()).start();    }    }  @Override  public void run() {    long beginTime=System.currentTimeMillis();    for (int i = 0; i < 100000000; i++) {      LazySingleton.getInstance();    }    System.out.println(System.currentTimeMillis()-beginTime);  }}

首先判断instance是不是为null,如果为null,加锁初始化;如果不为null,直接返回instance。

/** * 解决同步关键字低效率 * */public class StaticSingleton {  private StaticSingleton() {    System.out.println("StaticSingleton is create");  }  private static class SingletonHolder {    private static StaticSingleton instance = new StaticSingleton();  }  public static StaticSingleton getInstance() {    return SingletonHolder.instance;  }}

单例模式使用内部类来维护单例的实例,当 StaticSingleton 被加载时,其内部类并不会被初始化,故可以确保当 StaticSingleton 类被载入 JVM 时,不会初始化单例类,而当 getInstance() 方法调用时,才会加载 SingletonHolder,从而初始化instance。同时,由于实例的建立是时在类加载时完成,故天生对多线程友好,getInstance() 方法也无需使用同步关键字。

登记式单例

  • //类似Spring里面的方法,将类名注册,下次从里面直接获取。  
public class Singleton3 {  private static Map<String, Object> map = new HashMap<String, Object>();  static {    /*Singleton3 single = new Singleton3();    map.put(single.getClass().getName(), single);*/  }  // 保护的默认构造子  protected Singleton3() {  }  // 静态工厂方法,返还此类惟一的实例  public static Object getInstance(String name) {    if (name == null) {      name = Singleton3.class.getName();      System.out.println("name == null" + "--->name=" + name);    }    if (map.get(name) == null) {      try {        map.put(name, Class.forName(name).newInstance());      } catch (InstantiationException e) {        e.printStackTrace();      } catch (IllegalAccessException e) {        e.printStackTrace();      } catch (ClassNotFoundException e) {        e.printStackTrace();      }    }    return map.get(name);  }  public static void main(String[] args) {    Singleton3 single3 =(Singleton3) Singleton3.getInstance("demo.pattern.singleton.Singleton3");    Singleton3 single2 =(Singleton3) Singleton3.getInstance("demo.pattern.singleton.Singleton3");    System.out.println(single2);    System.out.println(single3);  }}

登记式单例实际上维护了一组单例类的实例,将这些实例存放在一个Map(登记薄)中,对于已经登记过的实例,则从Map直接返回,对于没有登记的,则先登记,然后返回。

参考资料

http://www.ibm.com/developerworks/cn/java/j-lo-Singleton/