单例模式

Posted on 2021-06-20 Edited on 2025-10-31 Views: Waline:

了解一下

核心作用

保证一个类只有一个实例，并且提供一个访问该实例的全局访问点

常见的五种单例模式的是实现方式

饿汉式（线程安全，调用效率高，不能延时加载）
懒汉式（线程安全，调用效率不高，可以延时加载）
DCL懒汉式（由于JVM底层内部模型原因，偶尔会出现问题，不推荐使用）
饿汉式改进（静态内部类，线程安全，调用效率高，可以延时加载）
枚举单例（线程安全，调用效率高，不能延时加载）

饿汉式


//饿汉式单例模式

public class demo1 {

    //1. 私有化构造器

    private demo1(){

    }

//    2. 类初始化的时候，立即加载该对象；由于用了static关键字，在类装载的时候就初始化对象，

//    不存在并发问题，因为一加载就出来了

    private static demo1 instance=new demo1();

    //3. 提供获取该对象的方法;由于不存在并发问题，所以没有加synchronized关键字，效率高；如果考虑到并发情况，是要加synchronized关键字的；

    public static  demo1 getInstance(){

        return instance;

    }

}

//问题：如果在这个类中，加了一些开辟空间的方法，那么不管我用不用这个类，这个块空间都被占用了，

//浪费了资源，理想情况应该是在调用getInstance方法的时候，再去开辟空间；

class demo1Test{

    public static void main(String[] args) {

        demo1 instance=demo1.getInstance();

        demo1 instance1=demo1.getInstance();

        System.out.println(instance==instance1);

    }

}

懒汉式


public class demo2 {

    //1. 私有化构造器

    private demo2(){

    }

    //2. 类初始化的时候，不立即加载该对象

    private static demo2 instance;

    //3. 提供获取该对象的方法，由于可能会出现有多个线程来进来的话，需要让他们排队，否则都有问题

    // 所以有synchronized同步这个关键字，效率低！

    public static synchronized demo2 getInstance(){

        if(instance==null)

        {

            instance=new demo2();

        }

        return instance;

    }

}

class demo2Test{

    public static void main(String[] args) {

        demo2 instance=demo2.getInstance();

        demo2 instance1=demo2.getInstance();

        System.out.println(instance==instance1);

    }

}

DCL懒汉式


//DCL懒汉式

public class demo3 {

    private demo3(){

    }

    //2. 类初始化的时候，不立即加载该对象

    private volatile static demo3 instance;

    //volatile是后来加的

    //3. 提供获取该对象的方法，由于可能会出现有多个线程来进来的话，需要让他们排队，否则都有问题

    // 所以有synchronized同步这个关键字，效率低！

    //不用synchronized可以用synchronized代码块，锁demo3这个类本身；双重检测

    //分析：现在不需要对整个方法进行同步了，将锁的范围变得更精细了，如果有个进程进来了，发现

    //这个instance对象没有被创建，有一个锁，他首先要和其他进程竞争本类的锁，获得锁之后，再次检查，

    //如果还是null，说明他是第一个竞争到这个锁的，于是他这个线程就负责创建这个对象，其他的线程

    //进来之后，直接调用即可

    public static  demo3 getInstance(){

        if(instance==null)

        {

            synchronized (demo3.class){

                if(instance==null)

                {

                    instance=new demo3();

                }

            }

        }

        return instance;

    }

}

//由于这个操作不是原子性操作，所以他会经过下面几个步骤

//1.分配内存

//2. 执行构造方法

//3. 执行地址

//可能会出现的问题：极端情况，一个线程进来了，走到instance=new demo3()，还没有出去方法，

//结果另一个线程进来了，就会直接走到 return instance;，这样instance就是一个新的对象，

//破环了单例模式，可能会发生一些意想不到的问题；在这种情况下加volatile关键字；

//volatile可以保证一个线程在对这个变量进行修改的时候，另一个线程，该变量的缓存就失效了，直接读内存中的值

class demo3Test{

    public static void main(String[] args) {

        demo3 instance=demo3.getInstance();

        demo3 instance1=demo3.getInstance();

        System.out.println(instance==instance1);

    }

}

静态内部类实现


//静态内部类实现

public class demo4 {

    private demo4(){

    }

    private static class InnerClass{

        private static final demo4 instance=new demo4();

    }

    public static demo4 getInstance(){

        return InnerClass.instance;

    }

}

//反射机制可以破坏private

class demo4Test{

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        demo4 instance=demo4.getInstance();

        //通过反射拿到instance

        Constructor<demo4> demo4Constructor=demo4.class.getDeclaredConstructor(null);

        demo4Constructor.setAccessible(true);

        demo4 instance1=demo4Constructor.newInstance();

        System.out.println(instance==instance1);

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

        System.out.println(instance1.hashCode());

    }

}

优化静态内部类


public class demo5 {

    private demo5(){

        synchronized (demo5.class){

            if(instance!=null)

            {

                throw new RuntimeException("不要试图用反射破坏单例模式！");

            }

        }

    }

    //2. 类初始化的时候，不立即加载该对象

    private volatile static demo5 instance;

    public static  demo5 getInstance(){

        if(instance==null)

        {

            synchronized (demo5.class){

                if(instance==null)

                {

                    instance=new demo5();

                }

            }

        }

        return instance;

    }

}

class demo5Test{

    public static void main(String[] args) throws Exception {

        demo5 instance=demo5.getInstance();

        //通过反射拿到instance

        Constructor<demo5> demo4Constructor=demo5.class.getDeclaredConstructor(null);

        demo4Constructor.setAccessible(true);

        demo5 instance1=demo4Constructor.newInstance();

        System.out.println(instance==instance1);

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

        System.out.println(instance1.hashCode());

    }

}

枚举


//枚举

//反射不能够破坏枚举

public enum demo6 {

    INTERFACE;

    public demo6 getInstance(){

        return INTERFACE;

    }

}

class demo6Test{

    public static void main(String[] args) {

        demo6 anInterface = demo6.INTERFACE;

        demo6 anInterface2 = demo6.INTERFACE;

        System.out.println(anInterface==anInterface2);

    }

}