java中单例模式经典代码案例（饿汉式，懒汉式，静态内部类式，懒汉式反射和反序列化漏洞处理）

优点：线程安全，效率高。缺点：不能延时加载，占用资源

package com.liangrui.singletonMode;


public class EvilHanStyle {
    //类初始化时加载对象，加载类，线程安全，但是会造成不必要的资源占用
    private static EvilHanStyle instance=new EvilHanStyle();

    //禁用构造器
    private EvilHanStyle(){
    }

    //获取单例对象的方法
    public static EvilHanStyle getInstance(){
        return instance;
    }
}

优点：实现了延时加载，避免资源占用。缺点：加入同步机制，效率低
此例子还防止了反射和反序列化漏洞

package com.liangrui.singletonMode;

import java.io.Serializable;


public class LazyStyle implements Serializable {

    //初始化时不加载对象，实现延时加载
    private static LazyStyle instance;

    //禁用构造器
    private LazyStyle(){
        //如果对象不为空，则抛出运行时异常，防止了反射的漏洞导致创建新的对象
        if (instance!=null){
            throw new RuntimeException();
        }
    }

    //加入同步，避免多线程调用导致创建不同对象，也就导致效率低
    public static synchronized LazyStyle getInstance(){
        //对象为空时才创建，避免资源占用
        if (instance==null){
            instance=new LazyStyle();
        }
        return instance;
    }

    //添加此方法，返回对象，防止反序列化漏洞创建新对象
    private Object readResolve(){
        return instance;
    }
}

优点：线程安全，效率高，实现了延时加载，避免不必要的资源占用，这种方式集合了饿汉式和懒汉式的优点

package com.liangrui.singletonMode;


public class StaticInnerClassStyle {

    //创建内部内，实现创建对象
    private static class StaticInnerClassStyleInstance{
        //定义常量保证对象唯一
        private static final StaticInnerClassStyle instance=new StaticInnerClassStyle();
    }

    //禁用构造器
    private StaticInnerClassStyle(){

    }

    //不需要使用同步，效率高
    public static StaticInnerClassStyle getInstance(){
        return StaticInnerClassStyleInstance.instance;
    }
}