单例模式是比较常见的设计模式。
是一种常用的软件设计模式,在它的核心结构中值包含一个被称为单例的特殊类。一个类只有一个实例,即一个类只有一个对象实例。
单例模式的优点
我们从单例模式的定义和实现,可以知道单例模式具有以下几个优点:
在内存中只有一个对象,节省内存空间;
避免频繁的创建销毁对象,可以提高性能;
避免对共享资源的多重占用,简化访问;
为整个系统提供一个全局访问点。
- 有状态的工具类对象;
- 频繁访问数据库或文件的对象;
单例模式的使用场景
由于单例模式具有以上优点,并且形式上比较简单,所以是日常开发中用的比较多的一种设计模式,其核心在于为整个系统提供一个唯一的实例,其应用场景包括但不仅限于以下几种:
- 有状态的工具类对象;
- 频繁访问数据库或文件的对象;
1.第一种(懒汉式):
public class Singleton{
public static Singleton sInstance = null;
//构造函数声明为private,是阻止外部实例化这个类。因为默认无参数构造方法是public的。
private Singleton(){
}
public static Singleton getInstance(){
if (sInstance == null ) {
sInstance = new Singleton();
}
return sInstatce;
}
private void getValue(){
System.out.println("this is the easy singleton!");
}
}
在其他类里使用:
Singleton mSingleton = Singleton.getInstance();
mSingleton.getValue();
这个写法缺点:
特点:延迟加载,需要的时候才使用。
缺点:单线程使用是没问题的,但是我们的web开发都是需要并发的,所以这个代码适用场景较小,线程不安全
第二种(懒汉式)
public class Singleton1 {
public static Singleton1 sInstance = null;
public Singleton1 () {
}
public static Synchronized Singleton1 getInstance () {
if (sInstance == null) {
sInstance = new Singleton1();
}
return sInstance;
}
}
这种写法在getInstance()方法中加入了synchronized锁。能够在多线程中很好的工作,而且看起来它也具备很好的lazy loading(延迟加载),但是效率很低(因为锁),并且大多数情况下不需要同步。
第三种 (饿汉式):
public class Singleton3{
public static Singleton3 sInstance = new Singleton3();
private Singleton3() {
//构造函数声明为private,是阻止外部实例化这个类。因为默认无参数构造方法是public的。
}
public static Singleton3 getInstance() {
return sInstance;
}
}
这种方式基于classloder机制避免了多线程的同步问题,不过,instance在类装载时就实例化,这时候初始化instance显然没有达到lazy loading的效果
2.第四种(恶汉式,):
public class Singleton1{
public static Singleton1 sInstance = null;
static {
//在构造函数前就进行实例化
sInstance = new Singleton1();
}
private Singleton1() {
//构造函数声明为private,是阻止外部实例化这个类。因为默认无参数构造方法是public的。
}
public static Singleton1 getInstance() {
return sInstance;
}
}
都是在类初始化中即实例化sInstance.
优点:线程安全
缺点:不是延迟加载的,当构造这样的单例非常重量级,但是这个单例可能很久也用不到一次的时候比较受伤。(这样的场景比较少)(意思是占用内存)第五种(静态内部类):
public class Singleton5{
public static class SingletonHolder(){
private static sInstance = null;
static {
sInstance = new Singleton5();
}
}
public Singleton5(){
//构造函数声明为private,是阻止外部实例化这个类。因为默认无参数构造方法是public的。
}
public static Singleton5 getInstance() {
return SingletonHolder.sInstance;
}
public static final void main (String[] args) {
System.out.prinln("do anything");
}
}
这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程,它跟第三种和第四种方式不同的是(很细微的差别):第三种和第四种方式是只要Singleton类被装载了,那么instance就会被实例化(没有达到lazy loading效果),而这种方式是Singleton类被装载了,instance不一定被初始化。因为SingletonHolder类没有被主动使用,只有显示通过调用getInstance方法时,才会显示装载SingletonHolder类,从而实例化instance。想象一下,如果实例化instance很消耗资源,我想让他延迟加载,另外一方面,我不希望在Singleton类加载时就实例化,因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载,那么这个时候实例化instance显然是不合适的。这个时候,这种方式相比第三和第四种方法就显得更合理。
第六种(枚举):
enum Singleton6{
sInstance;
public void getInstatnce() {
System.out.println("something");
}
}
它不仅能避免多线程同步问题,而且还能防止反序列化重新创建新的对象。如果用枚举去实现一个单例,这样的加载有点类似于饿汉模式.
1.线程安全;
2.不会因为序列化而产生新的实例(因为它自己实现了readResolve方法);
3.防止反射攻击。(因为enum实际上是abstract的)
第七种(double check locked)
public class Singleton7 {
public static volatile Singleton7 sInstance = null;
public Singleton7 () {
}
public static Singleton7 getInstance () {
if (sInstance == null) {
Synchronized(Singleton7.class){
if (sInstance == null) {
sInstance = new Singleton7();
}
}
}
return sInstance;
}
}
双重检查锁定(DCL),若没有volatile 修饰,有因为内存模型的问题,会存在指令重排的问题。
增加了volatile修饰后:
1.禁止指令重排序
2.内存可见性
规则1可以确保外层null检查要么看到的是null,要么看到的是一个构造完整的对象,规则2可以解决之前浪费的问题。
问题点1:
单例模式唯一实现为什么必须要静态?
单例模式实现过程:
1.构造方法进行私有化修饰,防止直接被创建实例
2. 在本类中自定义一个对象(既然禁止其他程序创建该类的对象,就要自己创建一个供程序使用,否则类就没法用,更不是单例)
3. 提供一个可访问类自定义对象的类成员方法(对外提供该对象的访问方式)。
这就是说其他地方使用该类创建对象,那就在类里面创建方法来访问自定义的对象。
访问类中的方法有两种方式:1.创建类对象,用对象来访问类中的方法 2. 直接使用类来访问,如类名.方法名();
但是在单例模式下,因为不能创建类的对象, 所以只能用类来访问。 用类访问就要用static 来修饰,同时因为静态方法不能访问非静态成员变量,所以自定义的实例变量也是static的。
这就是单例模式唯一实现必须要静态的原因。
问题点2:
枚举为什么可以实现反序列化?
因为在enum 类中实现了readObject, 并私有化,无法对枚举进行反序列化
public abstract class Enum<E extends Enum<E>>
implements Comparable<E>, Serializable {
····
/**
* prevent default deserialization
*/
private void readObject(ObjectInputStream in) throws IOException,
ClassNotFoundException {
throw new InvalidObjectException("can't deserialize enum");
}
private void readObjectNoData() throws ObjectStreamException {
throw new InvalidObjectException("can't deserialize enum");
}
}
一般情况下,单例类实现了序列化接口,readObject会一直返回新的对象,会破坏单例,所以可以在类中实现如下方法:
//readResolve to prevent another instance of Singleton
private Object readResolve(){
return INSTANCE;
}
问题3:
为什么枚举单例可以线程安全?
根据反编译枚举单例的代码来看,创建对象是在静态代码块中实现,静态代码快会在类创建初始化时就执行,可以保证安全.