设计模式初学—单例模式

单例模式

所谓单例模式就是确保一个类只有一个实例，并提供全局访问点

单例模式又分懒汉单例和饿汉单例

饿汉单例

饿汉单例是即时加载的模式，在创建一个单例类的时候就初始化一个实例，并通过方法去返回这个实例

public class Singleton{
	private static Singleton a = new Singleton();
	private Singleton(){
	
	}
	public static getSingleton(){
		return a;
	}
}

由于static语句在类加载的时候就已经初始化，所以a这个实例在加载这个类的时候就已经被初始化了，而且确保一个类只有a这一个实例

之所以叫它饿汉单例模式，是因为它在类加载的时候就已经实例化一个实例了，不管这个类有没有被用到，这样的单例模式是线程安全的，但是也丢失了延迟加载所带来的节省资源的效果

懒汉单例

懒汉单例模式相比饿汉单例，是一种延迟加载的效果，当没有用到这个类的时候节省了资源

public class Singleton{
	private static Singleton a;
	private Singleton(){
	
	}
	public static Singleton getSingleton(){
		if(a==null)
			a = new Singleton();
		return a;
	}
}

但是这么一来，这个类就变得线程不安全起来了，试想一下同时有两个线程进入到if()语句，同时判断到a==null，就会进行两次实例化

如果想要变得线程安全，就要用双重校验锁和volatile关键字

懒汉单例的线程安全化

public class Singleton{
	private volatile static Singleton a;
	private Singleton(){
	
	}
	public static Singleton getSingleton(){
		if(a==null){
			Synchronized(Singleton.class){
				if(a==null)
					a = new Singleton();
			}	
		}	
		return a;
	}
}

双重校验锁主要是用到了synchronized，因为是static方法，所以需要锁住的类，这里主要说说为什么要用volatile来修饰a

java编译器有指令重排序的优化方法，a = new Singleton()这一操作包括以下三个步骤：
1、在栈里分配空间
2、初始化a
3、将a指向栈里分配的空间

指令重排也就是，在无任何依赖关系的情况下，java编译器会有可能不按顺序执行语句，尽量优化编译，那么就会出现以下的情况：

线程一执行了1和3，此时a!null了，然后线程二判断a!=null，会执行return语句，而现在a并未被初始化，则会导致问题的出现

所以我们使用了volatile来修饰a

静态内部类实现

其实，懒汉单例模式还可以用静态内部类来实现

public class Singleton{
	private Singleton(){}
	
	private static class SingletonHelper(){
		private static final Singleton A = new Singleton();;
	}

	public static Singleton getSingleton(){
		return SingletonHelper.A;
	}
}

由于是静态内部类，在Singleton被加载的时候不会被加载，只有当调用getSingleton方法才会使得SingletonHelper被加载进来，而且只被加载一次，这是利用了jvm实现线程安全

枚举实现

但是，这样还不够，程序员可以通过反射去修改你的构造函数权限，设置成public，然后调用构造函数去实例化，这种方法称为反射攻击，而我们可以利用枚举来防止这种攻击

public enum Singleton {

    INSTANCE;

    private String objName;


    public String getObjName() {
        return objName;
    }


    public void setObjName(String objName) {
        this.objName = objName;
    }


    public static void main(String[] args) {

        // 单例测试
        Singleton firstSingleton = Singleton.INSTANCE;
        firstSingleton.setObjName("firstName");
        System.out.println(firstSingleton.getObjName());
        Singleton secondSingleton = Singleton.INSTANCE;
        secondSingleton.setObjName("secondName");
        System.out.println(firstSingleton.getObjName());
        System.out.println(secondSingleton.getObjName());

        // 反射获取实例测试
        try {
            Singleton[] enumConstants = Singleton.class.getEnumConstants();
            for (Singleton enumConstant : enumConstants) {
                System.out.println(enumConstant.getObjName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试结果：

firstName
secondName
secondName
secondName