Java单例模式的7种实现方式

最新推荐文章于 2022-11-16 10:12:42 发布

nZk丶

最新推荐文章于 2022-11-16 10:12:42 发布

阅读量543

点赞数 2

分类专栏： Java基础文章标签： java 设计模式面试

本文链接：https://blog.csdn.net/weixin_43729854/article/details/107050728

版权

Java基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一.饿汉式

  单例实现-饿汉式：
  1为什么方法是静态的：
    不能new对象却想调用类中方法，方法必然是静态的，
    静态方法只能调用静态成员，所以对象也是静态的。

  2.为什么对象的访问修饰符是private，不能是public 吗？
    不能，如果访问修饰符是Public，则Single.s也可以得到该类对象，
    这样就造成了不可控。
 
  3.加载类的什么周期有关，static修饰的静态变量，类，在类加载时已经被初始化了，
    getInstance是在使用阶段操作，安全是有类加载机制保证
 
  特点：线程安全，无法实现实例懒加载策略。


public class Single1 {
     private static final Single1 s=new Single1();
     private Single1(){}
     public static Single1 getInstance(){
         return s;
     }

    public static void main(String[] args) {
         //类加载过程
        //7步     static -使用-销毁对象
        Single1 single1 = Single1.getInstance();
    }
}

二.懒汉式

懒汉式和饿汉式相比的区别就是懒汉式创建了延迟对象同时饿汉式的实例对象是被修饰为final类型。
 
  优点：懒汉式的好处是显而易见的，它尽最大可能节省了内存空间。
  缺点：在多线程编程中，使用懒汉式可能会造成类的对象在内存中不唯一，
  虽然通过修改代码可以改正这些问题，但是效率却又降低了。
 
  饿汉式在实际开发中使用的比较多。

  特点：线程不安全，实现了实例懒加载策略。

public class Single2 {
    private static Single2 s = null;
    private Single2() { }

    public static Single2 getInstance() {
        //两个线程同时进行if (s == null)判断，则都会进入if条件吗，就会创建对个实例
        if (s == null)
            s = new Single2();
        return s;
    }
}

三.全局锁式

  单例模式-全局锁式

  特点：线程安全，且实现了懒加载策略，但是线程同步时效率不高（synchronized是个重量级锁）。

public class Single3 {
    private static Single3 single3;
    private Single3() {}

    //synchronized修饰的是静态方法，锁类对象
    public synchronized static Single3 getInstance() {
        if (single3 == null)
            single3 = new Single3();
        return single3;
    }
}

四.静态代码块式

  静态代码块式
 
  特点：线程安全，类主动加载时才初始化实例，实现了懒加载策略，且线程安全。

public class Single4 {
    private final static Single4 singleton4;
    private Single4() { }

    static {
        singleton4 = new Single4();
    }

    public static Single4 getInstance() {
        //使用之前将singleton4属性通过静态代码块实现
        return singleton4;
    }

    public static void main(String[] args) {
        //第一次调用Single4，JVM需要负责将Single4加载到内存中，在加载的过程处理静态代码块
        Single4.getInstance();
        //第二次调用Single4，JVM中已经存在Single4，直接使用getInstance
        Single4.getInstance();
    }
}

五.双重校验锁式

特点：线程安全，且实现了懒加载策略，同时保证了线程同步时的效率。

但是volatile强制当前线程每次读操作进行时，保证所有其他的线程的写操作已完成。

volatile使得JVM内部的编译器舍弃了编译时优化，对于性能有一定的影响。

public class Single5 {
    private static volatile Single5 singleton5;
    private Single5() {}

    public  static Single5 getInstance() {
        if (singleton5 == null) {
            synchronized (Single5.class) {
                if (singleton5 == null) {
                    //内层if判断使用的时间（起作用时机）
                    //第一次两线程同时调用getInstance，都会进入外层if判断
                    //内层if判断是针对第二个进入synchronized代码块线程，此时第一个线程已经创建出对象
                    //第二个线程无需创建
                    singleton5 = new Single5();
                }
            }
        }
        return singleton5;
    }
}

六.静态内部类式

 单例模式-静态内部类式【推荐】
 和静态代码块的思路是一样的
 特点：线程安全，不存在线程同步问题，
 且单例对象在程序第一次 getInstance() 时主动加载 SingletonHolder 和其 静态成员 INSTANCE，
 因而实现了懒加载策略。

public class Single6 {
    private Single6() {}

    private static class SingletonHolder {
        private static final Single6 INSTANCE = new Single6();
    }

    public static Single6 getInstance() {
        return Single6.SingletonHolder.INSTANCE;
    }
}

七.枚举方式

 单例模式-枚举方式
 
 特点：线程安全，不存在线程同步问题，且单例对象在枚举类型 INSTANCE
 第一次引用时通过枚举的 构造函数 初始化，因而实现了懒加载策略。
 
 这种方式是Effective Java作者 Josh Bloch 提倡的方式，
 它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，
 可谓是很坚强的壁垒啊.

public class Single7 {
    private Single7() {}

    enum SingletonEnum {
        INSTANCE;

        private final Single7 singleton7;
        private SingletonEnum() {
            singleton7 = new Single7();
        }
    }

    public static Single7 getInstance() {
        return SingletonEnum.INSTANCE.singleton7;
    }
}

共同学习，共同进步