单例设计模式精讲（饿汉式和懒汉式实现的重要方法）

目录

什么叫做单例模式？

饿汉式和懒汉式的区别？

饿汉式-方式1（静态变量方式）

饿汉式-方式2（静态代码块方式）

懒汉式-方式1（线程不安全）

懒汉式-方式2（线程安全）

懒汉式-方式3（双重检查锁）

懒汉式-方式4（静态内部类方式）

---

什么叫做单例模式？

        涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供 了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

饿汉式和懒汉式的区别？

        饿汉式：类加载就会导致该单实例对象被创建
        懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建
        导致类加载的情况：new 对象，创建子类，调用静态属性
        类加载是什么意思：就是把你的变量和方法存在内存当中
        代码区别如下：
        人话来说就是创建对象的时机不一样，如果看不懂的话建议去补java基础静态这一块的知识

//饿汉式
public class Singleton {

    private Singleton(){}
//    提前创建好单列对象；
    private static Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }

}
//测试代码：
public class Test {
    public static void main (String[] args) {
        //因为这里调用的是静态方法，所以导致类加载，就会执行 new Singleton();从而创建对象
        //导致类加载的情况：new 对象，创建子类，调用静态属性
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance==instance1);
    }
}
============================================================================
//饿汉式
public class Singleton {
    private Singleton(){}
    private static Singleton instance;
    public static Singleton getInstance(){
        if (instance==null){
            //调用的时候才创建对象
            //判短对象为空才创建对象
            instance=new Singleton();
        }
        return instance;
    }
}
public class Test {
    public static void main (String[] args) {
        //调用方法的时候才创建对象
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance==instance1);
    }
}

饿汉式-方式1（静态变量方式）
 

/**
* 饿汉式
* 静态变量创建类的对象
*/
public class Singleton {
//私有构造方法
private Singleton() {}
//在成员位置创建该类的对象
private static Singleton instance = new Singleton();
//对外提供静态方法获取该对象
public static Singleton getInstance() {
return instance;
}
}

缺点：
该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。 instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存 的浪费。

饿汉式-方式2（静态代码块方式）
 

/**
* 恶汉式
* 在静态代码块中创建该类对象
*/
public class Singleton {
//私有构造方法
private Singleton() {}
//在成员位置创建该类的对象
private static Singleton instance;
static {
instance = new Singleton();
}
//对外提供静态方法获取该对象
public static Singleton getInstance() {
return instance;
}
}

缺点：
该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着 类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。

懒汉式-方式1（线程不安全）

/**
* 懒汉式
* 线程不安全
*/
public class Singleton {
//私有构造方法
private Singleton() {}
//在成员位置创建该类的对象
private static Singleton instance;
//对外提供静态方法获取该对象
public static Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}

缺点：
从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量，并没有进行对象的 赋值操作，那么什么时候赋值的呢？当调用getInstance()方法获取Singleton类的对象的时 候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现 线程安全问题。

懒汉式-方式2（线程安全）
 

/**
* 懒汉式
* 线程安全
*/
public class Singleton {
//私有构造方法
private Singleton() {}
//在成员位置创建该类的对象
private static Singleton instance;
//对外提供静态方法获取该对象
public static synchronized Singleton getInstance() {
if(instance == null) {
instance = new Singleton();
}
return instance;
}
}

缺点：
该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了 synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在 初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

就是每个现场都会拿到锁，导致效率降低，应该是当没有获取对象的谁时候拿到锁。

 

懒汉式-方式3（双重检查锁）
 

public class Singleton {
    private Singleton(){}
    //声明一个Singleton类型的变量
    private static Singleton instance;
    public static Singleton getInstance(){
        if (instance==null){
            //为空的时候才会拿到锁
            synchronized (Singleton.class){
                if (instance==null){
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
}

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检 测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问 题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。 要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关 键字可以保证可见性和有序性。
 

懒汉式-方式4（静态内部类方式）

 

public class Singleton {
//私有构造方法
private Singleton() {}
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
//对外提供静态方法获取该对象
public static Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}

 第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用getInstance，虚拟机加 载SingletonHolder 并初始化INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。 小结： 静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任 何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。