设计模式之单例

趁着过年假期把java设计模式进行一下总结,首先从单例开始

饿汉式:

public class Singleton {
    private static Singleton instance;
    private Singleton(){}
    public static Singleton getInstance(){
        if (null == instance){
            instance = new Singleton();
        }
        return instance;
    }
}

    成员属性初始化时创建对象实例,私有化构造器使之无法从外部创建对象,提供公共的对外方法,这是最简单的单例的实现;优点是没有并发问题,缺点是该单例类被加载后,实例对象就被创建,在程序运行时一直存在,比较浪费资源;如果单例对象比较轻,占用的资源不多,则可以使用该方法实现单例

懒汉式:

public class Singleton {
	private static Singleton instance;
	private Singleton(){}
	public static Singleton getInstance(){
		if (null == instance){
			instance = new Singleton();
		}
		return instance;
	}
}

     私有化构造器,提供公共的获取方法,只有在第一次调用该方法时才会创建对象,之后调用都会返回同一个instance;优点是在使用时才创建单例对象,效率比较高,缺点是会有并发问题的产生;

加锁的懒汉式:   

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

    对比一般的懒汉式,在静态方法上添加了一个同步锁,这种方式可以解决并发问题,但是在方法上添加同步锁会降低效率,如果很频繁的使用则不推荐这种方式;

双重校验:

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

        假设线程AB同时进入第一个if判断,线程A进入同步代码块,线程B等待,然后线程A执行if中的语句,创建单例实例,结束同步代码块,随后线程B进入同步代码块,进行第二个if的判断,发现实例已经被创建,不再创建对象,直接返回instance;这种方法看起来很完美,即实现了单例,又解决的并发问题,但是,由于指令重排优化机制,这种方式还是有风险的;指令重排优化是指对象的创建于对象内存地址的赋值的顺序不一致,可能出现对象分配地址之后,将地址赋给instance对象,但并未进行对象初始化的情况,举个例子,线程A进入第二个if语句中,执行instance = new Singleton();语句,对象分配内存并赋值给instance但并未执行构造器(未初始化),此时instance虽然有对象引用的地址,但是并未初始化,线程B进行第二个if判断为false,直接返回instance,此时该对象还不能用,则会报错;

volatile重排优化:   

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

           使用volatile关键字修饰instance,此时禁用指令重排优化,则instance = new Singleton();在赋值之前会保证进行初始化;这种方法是比较常用的,但是注意volatile是在jdk1.5之后出现的;

内部类方式:   

public class Singleton {
	private static class holder{
		public static Singleton instance = new Singleton();
	}
	private Singleton(){}
	public static Singleton getInstance(){
		return holder.instance;
	}
}

                 内部类不会随着单例类的加载而加载,内部类创建利用类加载机制保证不会出现并发问题;这种方式比较常用;

枚举方式:   

public enum Singleton {
	instance;
	public void method(){}
}

                 枚举的方式也可以完美的解决单例的并发问题,但是这种方式不常用;

上边介绍的都是单例的实现方式,下面说一说使用场景,当程序中只需要一个对象时,就使用单例模式,spring创建的javabean对象默认都是单例的