单例设计模式

单例设计模式

采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只能提供一个取得其对象实例的方法（静态方法）。
比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目只需要一个SessionFactory就够，这时就会使用到单例模式。
一. 单例设计模式的八种方式：
饿汉式（静态常量）、饿汉式（静态代码块）、懒汉式（线程不安全）、懒汉式（线程安全，同步方法）、懒汉式（线程安全，同步代码块）、双重检查、静态内部类、枚举

1. 饿汉式（静态常量）
   ①. 构造器私有化（防止 new）
   ②. 类的内部创建对象
   ③. 向外暴露一个静态的公共方法。 getInstance

package com.percy.singleton.type1;
public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);
        System.out.println("instance.hashCode = " + instance.hashCode());
        System.out.println("instance2.hashCode = " + instance2.hashCode());
    }
}
class Singleton{
    //1.构造器私有化 外部不能new
    private Singleton() {
    }
    //2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();
    //3.提供一个共有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点说明：
	①. 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步的问题。
	②. 缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未是哟ing过这个实例，则会造成内存的浪费。
	③. 这种基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致装载的原因有很多，因此不能确定有其它的方式（或者其它的静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果。
	④. 结论：这种单例模式可用，可能造成内存浪费

2. 饿汉式（静态代码块）

package com.percy.singleton.type2;
	public class SingletonTest02 {
	    public static void main(String[] args) {
	        Singleton instance = Singleton.getInstance();
	        Singleton instance2 = Singleton.getInstance();
	        System.out.println(instance == instance2);
	        System.out.println("instance.hashCode = " + instance.hashCode());
	        System.out.println("instance2.hashCode = " + instance2.hashCode());
	    }
	}
	class Singleton{
	    //1.构造器私有化 外部不能new
	    private Singleton() {
	    }
	    //2.本类内部创建对象实例
	    private static Singleton instance;
	    static {//在静态代码块中，创建单例对象
	        instance = new Singleton();
	    }
	    //3.提供一个共有的静态方法，返回实例对象
	    public static Singleton getInstance() {
	        return instance;
	    }
	}

-------------------------------------
true
instance.hashCode = 31168322
instance2.hashCode = 31168322

优缺点说明：
	①. 这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
	②. 结论：这种单例模式可用，但是可能造成内存浪费

3. 懒汉式（线程不安全）

package com.percy.singleton.type3;
	public class SingletonTest03 {
	    public static void main(String[] args) {
	        System.out.println("懒汉式1，线程不安全~");
	        Singleton instance = Singleton.getInstance();
	        Singleton instance2 = Singleton.getInstance();
	        System.out.println(instance == instance2);
	        System.out.println("instance.hashCode = " + instance.hashCode());
	        System.out.println("instance2.hashCode = " + instance2.hashCode());
	    }
	}
	class Singleton{
	    private static Singleton instance;
	    private Singleton() {
	    }
	    //提供一个静态的公有方法，当时用到该方法时，才去创建 instance
	    public static Singleton getInstance() {
	        if(instance==null) {
	            instance = new Singleton();
	        }
	        return instance;
	    }
	}

4. 懒汉式（线程安全，同步方法）

package com.percy.singleton.type4;
	public class SingletonTest04 {
	    public static void main(String[] args) {
	        System.out.println("懒汉式2，线程安全~");
	        Singleton instance = Singleton.getInstance();
	        Singleton instance2 = Singleton.getInstance();
	        System.out.println(instance == instance2);
	        System.out.println("instance.hashCode = " + instance.hashCode());
	        System.out.println("instance2.hashCode = " + instance2.hashCode());
	    }
	}
	class Singleton{
	    private static Singleton instance;
	    private Singleton() {
	    }
	    //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
	    public static synchronized Singleton getInstance() {
	        if(instance==null) {
	            instance = new Singleton();
	        }
	        return instance;
	    }
	}

5. 懒汉式（线程安全，同步代码块）

package com.percy.singleton.type5;
	public class SingletonTest05 {
	    public static void main(String[] args) {
	        System.out.println("懒汉式3，线程安全~");
	        Singleton instance = Singleton.getInstance();
	        Singleton instance2 = Singleton.getInstance();
	        System.out.println(instance == instance2);
	        System.out.println("instance.hashCode = " + instance.hashCode());
	        System.out.println("instance2.hashCode = " + instance2.hashCode());
	    }
	}
	class Singleton{
	    private static Singleton instance;
	    private Singleton() {
	    }
	    //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
	    public static synchronized Singleton getInstance() {
	        if(instance==null) {
	            synchronized (Singleton.class) {
	                instance = new Singleton();
	            }
	        }
	        return instance;
	    }
	}

6. 双重检查

package com.percy.singleton.type6;
	public class SingletonTest06 {
	    public static void main(String[] args) {
	        System.out.println("双重检查");
	        Singleton instance = Singleton.getInstance();
	        Singleton instance2 = Singleton.getInstance();
	        System.out.println(instance == instance2);
	        System.out.println("instance.hashCode = " + instance.hashCode());
	        System.out.println("instance2.hashCode = " + instance2.hashCode());
	    }
	}
	class Singleton{
	    private static Singleton instance;
	    private Singleton() {
	    }
	    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
	    //同时保证了效率，推荐使用
	    public static Singleton getInstance() {
	        if(instance==null) {
	            synchronized (Singleton.class) {
	                if(instance==null) {
	                    instance = new Singleton();
	                }
	            }
	        }
	        return instance;
	    }
	}

7. 静态内部类

package com.percy.singleton.type7;
	public class SingletonTest07 {
	    public static void main(String[] args) {
	        System.out.println("使用静态内部类完成单例模式");
	        Singleton instance = Singleton.getInstance();
	        Singleton instance2 = Singleton.getInstance();
	        System.out.println(instance == instance2);
	        System.out.println("instance.hashCode = " + instance.hashCode());
	        System.out.println("instance2.hashCode = " + instance2.hashCode());
	    }
	}
	class Singleton{
	    private static Singleton instance;
	    private Singleton() {
	    }
	    //写一个静态内部类，该类中有一个静态属性 Singleton
	    private static class SingletonInstance{
	        private static final Singleton INSTANCE = new Singleton();
	    }
	    //提供一个静态的公有方法，直接返回 SingletonInstance.INSTANCE
	    public static Singleton getInstance() {
	        return SingletonInstance.INSTANCE;
	    }
	}

8. 枚举

package com.percy.singleton.type8;
	public class SingletonTest08 {
	    public static void main(String[] args) {
	        System.out.println("使用枚举");
	        Singleton instance = Singleton.INSTANCE;
	        Singleton instance2 = Singleton.INSTANCE;
	        System.out.println(instance == instance2);
	        System.out.println("instance.hashCode = " + instance.hashCode());
	        System.out.println("instance2.hashCode = " + instance2.hashCode());
	    }
	}
	//使用枚举 可以实现单例 推荐
	enum Singleton{
	    INSTANCE;//属性
	    public void sayOK() {
	        System.out.println("ok~");
	    }
	}