1 单例模式

采用一定的方法保证整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）

• 单例模式有八种
• 饿汉式（静态常量）

• 饿汉式（静态代码块）

• 懒汉式（线程不安全）

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

• 懒汉式（线程不安全，同步代码块）

• 双重检查

• 静态内部类
• 枚举

饿汉式

饿汉式（静态常量）

构造器私有化（防止new）
类的内部创建对象
向外部暴露一个静态公共方法，getInstance

class Singleton {
    //1. 构造器私有化, 外部能new
    private Singleton() {
    }
    //2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();
    //3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

优点：写法简单，类装载的时候就完成了实例化，避免了线程同步问题

缺点：类装载的时候实例化没有达到懒加载的效果，可能会造成内存浪费

结论： 这种单例模式可以使用，但是可能造成内存浪费

饿汉式（静态代码块）

class Singleton{
    private static Singleton ins;
    //1. 构造器私有化, 外部能new
    private Singleton{
    }
    //2.本类内部创建对象实例
    static{
        ins = new Singleton();
    }
    //3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return ins;
    }
}

优缺点：同静态变量

懒汉式

懒汉式（线程不安全）（不能使用）

class Singleton {
    private static Singleton instance;

    private Singleton() {}

    //提供一个静态的公有方法，当使用到该方法时，才去创建 instance
    //即懒汉式
    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点：懒加载
缺点：线程不安全

懒汉式（线程安全 ）

方法上加锁（效率太低）

// 懒汉式(线程安全，同步方法)
class Singleton {
    private static Singleton instance;

    private Singleton() {}

    //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    //即懒汉式
    public static synchronized Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

代码块加锁

（双重检查） volitale 将修改立即更新到主内存 对其他线程可见 ，防止编译优化

class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
    //同时保证了效率, 推荐使用

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

        }
        return instance;
    }
}

静态内部类（推荐使用）

// 静态内部类完成， 推荐使用
class Singleton {
    //构造器私有化
    private Singleton() {}

    //写一个静态内部类,该类中有一个静态属性 Singleton
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton(); 
    }

    //提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE

    public static Singleton getInstance() {

        return SingletonInstance.INSTANCE;
    }
}

优点：线程安全，快，懒加载

枚举（避免反序列化 ，线程安全）

public class SingletonTest08 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);

        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());

        instance.sayOK();
    }
}

//使用枚举，可以实现单例, 推荐
enum Singleton {
    INSTANCE; //属性
    public void sayOK() {
        System.out.println("ok~");
    }
}

源码 Runtime