单例模式的简单实现

概念：整个程序只有一个对象
1.第一种方式（饿汉式）
三个步骤：

• （1）私有化构造方法
• （2）在类内部创建一个对象
• （3）通过公开的方法，返回这个对象
• 饿汉式：类一加载，对象就初始化
• 缺点：生命周期长太长，浪费时间
• 优点：线程安全

	//1.私有化构造方法
    private SingleTon1(){}
    //2.类内部创建一个对象
    private static final SingleTon1 instance = new SingleTon1();
    //3.通过公开的方法，返回这个对象
    public static SingleTon1 getInstance() {
        return instance;
    }

2.第二种方式（懒汉式）

• 三步骤:

• (1)私有化构造方法

• (2)在类内部创建一个对象

• (3)通过公开的方法，返回这个对象

• 好处：生命周期短，节省空间

• 缺点：线程不安全，必须使用同步解决

	//1.私有化构造方法
    //声明一个静态的布尔常量 默认为false
    private static boolean flag = false;
    private SingleTon2(){
        //如果对象已经存在，则抛出异常
        if (flag) {
            throw new RuntimeException("不能反射破解");
        }
    }
    //2.在类内部创建一个对象 
    //synchronized：原子性（互斥性）、可见性
    //volatile：可见性、有序性
    private static volatile SingleTon2 instance;
    //3.通过公开的方法，返回这个对象
    public static  SingleTon2 getInstance() {
        if (instance == null) {//目的：提高效率 双重检查，如果不为空 则直接返回instance 为空则进行同步处理判断
            //判断锁是否可用 效率低
            synchronized (SingleTon2.class) {
                if (instance == null) {
                    instance = new SingleTon2();
                    flag = true;
                }
            }
        }
        return instance;
    }

3.第三种写法（静态内部类，与第一种很相似）

• 静态内部类写法
• 优点：1 安全 2 生命周期短，节省空间

 	//1私有化构造方法
    private SingleTon3(){}
    //2在静态内部类中创建对象
    private static class Holder{
        private static final SingleTon3 instance=new SingleTon3();
    }
    //3通过公开方法返回这个对象
    public static SingleTon3 getInstance(){
        return Holder.instance;
    }