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

目录

什么叫做单例模式?

饿汉式和懒汉式的区别?

饿汉式-方式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 类的唯一性。 小结: 静态内部类单例模式是一种优秀的单例模式,是开源项目中比较常用的一种单例模式。在没有加任 何锁的情况下,保证了多线程下的安全,并且没有任何性能影响和空间的浪费。

你可能感兴趣的:(设计模式,java,单例模式)