1.单例模式
单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。这个类称为单例类。
3个要点:一是某个类只能有一个实例;而是必须自行创建这个实例;三是必须向整个系统提供这个实例。一般资源管理器、工厂类等都被设计成单例。
2.结构图
结构图很简单,一个Singleton,自己创建和持有自己的一个实例,并保持它唯一。
3.饿汉式单例
public class EagerSingleton {
private EagerSingleton() { }
public static EagerSingleton getInstance() {
return m_instance;
}
/** @label Creates */
private static final EagerSingleton m_instance = new EagerSingleton();
}
饿汉式单例中,类被加载时,单一实例就被创建。
4.懒汉式单例
public class LazySingleton {
private static LazySingleton m_instance = null;
/*
* 私有构造子
*
*/
private LazySingleton(){
}
/*
* 静态工厂方法,返还此类的唯一实例
*/
synchronized public static LazySingleton getInstance(){
if(m_instance == null){
m_instance = new LazySingleton();
}
return m_instance;
}
}
懒汉式单例在第一次使用时被创建,资源利用率方面比饿汉式单例好。
懒汉式单例在使用时,要考虑多个线程同时访问的同步。
5.双重检测加锁
懒汉式单例,采用线程同步synchronized 确保多个线程首次访问时只有一个线程进入并且创建实例。当实例被创建以后,也是每次都要经过同步才能获得实例,性能不太好。
于是有了双重检测加锁。
public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
获得实例时,先判断有没有实例,没有才进入同步块。不过这种方式,经证明在jvm中不成立,有可能会导致程序崩溃,所以不推荐。
崩溃理由在java编译器中,Singleton类的初始化和singleton变量的赋值顺序不可预料。如果一个线程在没有同步化的条件下读取singleton的值,并调用这个对象的方法,可能会发现这个并没有初始化完成。就是singleton有这个对象的引用,但是这个对象没有初始化完成,这个时候程序会崩溃。
6.静态内部类实现的懒汉
综合使用了Java的类级内部类和多线程缺省同步锁的知识,很巧妙地同时实现了延迟加载和线程安全。
1.相应的基础知识
- 什么是类级内部类?
简单点说,类级内部类指的是,有static修饰的成员式内部类。如果没有static修饰的成员式内部类被称为对象级内部类。
类级内部类相当于其外部类的static成分,它的对象与外部类对象间不存在依赖关系,因此可直接创建。而对象级内部类的实例,是绑定在外部对象实例中的。
类级内部类中,可以定义静态的方法。在静态方法中只能够引用外部类中的静态成员方法或者成员变量。
类级内部类相当于其外部类的成员,只有在第一次被使用的时候才被会装载。
- 多线程缺省同步锁的知识
大家都知道,在多线程开发中,为了解决并发问题,主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中,JVM已经隐含地为您执行了同步,这些情况下就不用自己再来进行同步控制了。这些情况包括:
1.由静态初始化器(在静态字段上或static{}块中的初始化器)初始化数据时
2.访问final字段时
3.在创建线程之前创建对象时
2.解决方案的思路
要想很简单地实现线程安全,可以采用静态初始化器的方式,它可以由JVM来保证线程的安全性。比如前面的饿汉式实现方式。但是这样一来,不是会浪费一定的空间吗?因为这种实现方式,会在类装载的时候就初始化对象,不管你需不需要。
如果现在有一种方法能够让类装载的时候不去初始化对象,那不就解决问题了?一种可行的方式就是采用类级内部类,在这个类级内部类里面去创建对象实例。这样一来,只要不使用到这个类级内部类,那就不会创建对象实例,从而同时实现延迟加载和线程安全。
public class Singleton {
private Singleton(){}
/**
* 类级的内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例
* 没有绑定关系,而且只有被调用到时才会装载,从而实现了延迟加载。
*/
private static class SingletonHolder{
/**
* 静态初始化器,由JVM来保证线程安全
*/
private static Singleton instance = new Singleton();
}
public static Singleton getInstance(){
return SingletonHolder.instance;
}
}
当getInstance方法第一次被调用的时候,它第一次读取SingletonHolder.instance,导致SingletonHolder类得到初始化;而这个类在装载并被初始化的时候,会初始化它的静态域,从而创建Singleton的实例,由于是静态的域,因此只会在虚拟机装载类的时候初始化一次,并由虚拟机来保证它的线程安全性。
这个模式的优势在于,getInstance方法并没有被同步,并且只是执行一个域的访问,因此延迟初始化并没有增加任何访问成本。
7.枚举实现
按照《高效Java 第二版》中的说法:单元素的枚举类型已经成为实现Singleton的最佳方法。用枚举来实现单例非常简单,只需要编写一个包含单个元素的枚举类型即可。
public enum Singleton {
/**
* 定义一个枚举的元素,它就代表了Singleton的一个实例。
*/
uniqueInstance;
/**
* 单例可以有自己的操作
*/
public void singletonOperation(){
//功能处理
}
}
这是从网上看来的实现方法,自己从来没用过,也很少见别人使用。
使用枚举来实现单实例控制会更加简洁,而且无偿地提供了序列化机制,并由JVM从根本上提供保障,绝对防止多次实例化,是更简洁、高效、安全的实现单例的方式。
8.结语
怎么实现单例,看自己的取舍。饿汉式单例用空间换时间,懒汉式单例和其优化(6),以时间换空间。7是大牛推荐的做法,不过只在java1.5及以后的版本能使用。