给大忙人写的单例模式的八种实现方法

TrueDei
69 阅读13分钟

介绍

我认为把知识给别人讲会，讲明白，自己才彻底明白。
努力把文章写好，写明白每一篇文章，分享给更多人。
一个赞、一个评论、一个关注，真的好开心，努力没有白费，得到了这么多人的认可。

文章作者：TrueDei
为什么叫TrueDei？
true在编程中代表的真，dēi不是英语，可以看成一个拼音，dēi是我们这里的方言；
真dēi：意思是真好玩。希望自己在IT世界中一直保持这个心态，心态决定一切。

作者博客首页：truedei.blog.csdn.net
文章原文地址：truedei.blog.csdn.net/article/det…
欢迎关注我，一起创造奇迹；代码改变世界，一点也没有错。

在这里插入图片描述

文章目录

一、单例模式介绍

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

二、单例模式的八种方式：

  • 1、饿汗式（静态常量）
  • 2、饿汗式（静态代码块）
  • 3、懒汉式（线程不安全）
  • 4、懒汉式（线程安全，同步方法）
  • 5、懒汉式（线程安全，同步代码块）
  • 6、双重检查
  • 7、静态内部类
  • 8、枚举

三、饿汗式

（一）饿汗式（静态常量）

通常实现方法：

  • 1、构造器私有化
  • 2、类的内部创建对象
  • 3、向外暴露一个静态的公共方法
  • 4、代码实现

代码实现：

public class SingLeton{

    //1.构造器私有化,外部可以new
    private SingLeton(){

    }

    //2.本类的内部创建对象
    private final static SingLeton singleton = new SingLeton();

    //3.向外暴露一个静态的公共的方法
    public static SingLeton getSingleton(){
        return singleton;
    }

}

测试代码：

package singleton.type1;

public class SingletonTest01 {


    public static void main(String[] args) {

        //测试
        SingLeton singLeton1 = SingLeton.getSingleton();
        SingLeton singLeton2 = SingLeton.getSingleton();

        //测试创建的两个是否相等
        System.out.println(singLeton1 == singLeton2);//true

        //可以查看hashCode是否相同
        System.out.println("singLeton1="+singLeton1.hashCode());
        System.out.println("singLeton2="+singLeton2.hashCode());

    }
}

测试结果：

true
singLeton1=1956725890
singLeton2=1956725890

Process finished with exit code 0

优缺点：

  • 1、优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
  • 2、缺点：在类装载的时候就完成实例化，没有达到懒加载的效果。如果从开始到程序结束窦娥米使用这个实例，则会造成内存的浪费。

结论：

代码简单可以正常使用，但是可能会造成资源浪费。

作者博客首页：truedei.blog.csdn.net
文章原文地址：truedei.blog.csdn.net/article/det…
欢迎关注我，一起创造奇迹；代码改变世界，一点也没有错。

（二）饿汗式（静态代码块）

相对于静态常量的方式只是把final常量给去掉了，然后再static{}静态代码块中初始化。

代码实现：

package singleton.type2;

public class SingLeton{

    //1.构造器私有化,外部可以new
    private SingLeton(){

    }

    //2.本类的内部创建对象
    private  static SingLeton singleton;


    //在静态代码块中创建单例模式
    static {
        singleton = new SingLeton();
    }

    //3.向外暴露一个静态的公共的方法
    public static SingLeton getSingleton(){
        return singleton;
    }

}

测试：

package singleton.type2;

public class SingletonTest02 {

    public static void main(String[] args) {

        //测试
        SingLeton singLeton1 = SingLeton.getSingleton();
        SingLeton singLeton2 = SingLeton.getSingleton();

        //测试创建的两个是否相等
        System.out.println(singLeton1 == singLeton2);//true

        //可以查看hashCode是否相同
        System.out.println("singLeton1="+singLeton1.hashCode());
        System.out.println("singLeton2="+singLeton2.hashCode());

    }
}

测试结果：

true
singLeton1=1956725890
singLeton2=1956725890

Process finished with exit code 0

可以看到效果还是一样的。

优缺点：

  • 1、这种方式和静态常量方式是相似的，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点都和静态常量的一样。

结论：

代码简单可以正常使用，但是可能会造成资源浪费。

四、懒汉式

（一）懒汉式（线程不安全）

通常实现方法：

  • 在初始化的时候判断一下是否已经初始化，如果初始化了，就直接返回，否则就初始化，然后返回实例结果。
  • 实际开发中，不推荐使用。

代码实现：

package singleton.type3;

public class SingLeton {

    private static SingLeton singleton;

    private SingLeton(){

    }

    //提供一个静态的共有方法，当使用到该方法时，才去创建singleton

    //就是所说的懒汉式，只有在使用的时候才会去创建对象
    public static SingLeton getSingleton(){
        if(singleton == null){
            singleton = new SingLeton();
        }

        return singleton;
    }
}

测试代码：

package singleton.type3;

public class SingletonTest03 {

    public static void main(String[] args) {
        //测试
        System.out.println("懒汉式：");
        SingLeton singLeton1 = SingLeton.getSingleton();
        SingLeton singLeton2 = SingLeton.getSingleton();

        //测试创建的两个是否相等
        System.out.println(singLeton1 == singLeton2);//true

        //可以查看hashCode是否相同
        System.out.println("singLeton1="+singLeton1.hashCode());
        System.out.println("singLeton2="+singLeton2.hashCode());

    }
}

测试结果：

懒汉式：
true
singLeton1=1956725890
singLeton2=1956725890

优缺点：

  • 1、起到了懒加载的效果（用到才会创建，用不到就不会创建），但是只能在单线程下使用；
  • 2、如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不能使用这种方式。

结论：

在实际开发中，不能使用这种方式，因为有潜在的风险。这种写法，就破坏了单利模式的原则了。

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

通常实现方法：

  • 因为上面那个是线程不安全的，所以下面这个是为了改造上面的写法而诞生的。
  • 在初始化方法中添加synchronized关键字；如果有多个需要执行的话，就不让其余的线程去执行了。
  • 这样的话，如果来了很多使用的人，就会排队一个一个执行，不会造成上面的情况。

代码实现：

package singleton.type4;

/**
 * （二）、懒汉式（线程安全，同步方法）
 * 懒汉式的第二种写法，解决线程安全
 */
public class SingLeton {

    private static SingLeton singleton;

    private SingLeton(){

    }

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

        return singleton;
    }
}

测试代码：

package singleton.type4;

public class SingletonTest04 {

    public static void main(String[] args) {
        //测试
        System.out.println("懒汉式：线程安全");
        SingLeton singLeton1 = SingLeton.getSingleton();
        SingLeton singLeton2 = SingLeton.getSingleton();

        //测试创建的两个是否相等
        System.out.println(singLeton1 == singLeton2);//true

        //可以查看hashCode是否相同
        System.out.println("singLeton1="+singLeton1.hashCode());
        System.out.println("singLeton2="+singLeton2.hashCode());

    }
}

测试结果：

懒汉式：线程安全
true
singLeton1=1956725890
singLeton2=1956725890

优缺点：

  • 1、解决了线程不安全问题
  • 2、效率太低了，每个线程在想获得类的实例的时候，执行getXX()方法都要进行同步。其实这个方法只执行一次实例化代码就够了，后面在排队想获得该类实例的线程直接return就行了。方法进行同步效率太低。

结论：

在实际开发中效率太低了，不推荐使用这种方式。

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

代码实现：

package singleton.type5;

/**
 （三）、懒汉式（线程安全，同步代码块）
 */
public class SingLeton {

    private static SingLeton singleton;

    private SingLeton(){

    }


    //懒汉式
    public static SingLeton getSingleton(){
        if(singleton == null){
            synchronized (SingLeton.class){
                singleton = new SingLeton();
            }
        }

        return singleton;
    }
}

优缺点：

  • 1、这种写法的本意是想对第四种实现方式进行改进，因为前面同步方法效率太低，改为同步产生实例化的代码块。
  • 2、但是这种同步并不能起到线程永不的作用。跟第三种实现方式遇到的情况是一样的，加入一个线程进入if判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

结论：

在实际开发中，不能使用这种方式。

五、双重检查（推荐使用）

推荐使用

可以解决：

  • 1、可以解决线程安全的问题；
  • 2、可以解决效率的问题；
  • 3、懒加载也符合要求。

代码实现：

package singleton.type6;

/**
 五、双重检查（推荐使用）
 推荐使用
 */
public class SingLeton {

    //加上volatile关键字：可以让共享的变量达到共享的结果
    private static volatile SingLeton  singleton;

    private SingLeton(){

    }


    //提供一个静态的共有方法，加入双重检查代码，
    // 解决了线程安全问题
    // 解决了懒加载问题
    // 保证了效率
    public static SingLeton getSingleton(){
        if(singleton == null){
            synchronized (SingLeton.class){
                /*
                 如果有A和B同时进入了这个代码块，那么假设A先进入了if代码块；
                 假设B后来了，走到if代码块的时候，发现类已经实例化了，就直接返回数据了

                 假设后面又来了C、D、E，那么根本就不会执行到这里，在第一层的if判断就被截止了，直接返回了
                 */
                if(singleton==null) {//1：现在A进来了，为null；
                    singleton = new SingLeton();//2：把类实例化，然后返回给A。
                }
            }
        }
        return singleton;
    }
}

测试代码：

package singleton.type6;

/**
 * 五、双重检查（推荐使用）
 */
public class SingletonTest06 {

    public static void main(String[] args) {
        System.out.println("双重检查:");
        SingLeton singLeton1 = SingLeton.getSingleton();
        SingLeton singLeton2 = SingLeton.getSingleton();

        //测试创建的两个是否相等
        System.out.println(singLeton1 == singLeton2);//true

        //可以查看hashCode是否相同
        System.out.println("singLeton1="+singLeton1.hashCode());
        System.out.println("singLeton2="+singLeton2.hashCode());

    }
}

测试结果：

双重检查:
true
singLeton1=1956725890
singLeton2=1956725890

测试也是没有问题

优缺点：

  • 1、Double-Check概念是多线程开发经常使用到的，如代码中所示，使用了两次if(singleton==null)检查，这样就可以保证了线程的安全。
  • 2、这样，实例化代码只用执行一次，后面再次访问时，判断if(singleton==null)，直接return已经实例化的对象，也避免了重复进行方法同步。

结论：

保证了线程安全；延迟加载；效率较高；

在实际开发中，推荐使用这种方式。

六、静态内部类（推荐使用）

静态内部类特点：

  • 1、当外部类被装载时，内部类并不会装载；
  • 2、当外部类调用内部类的时候，才会装载，而且只会装载一次；而且在装载的时候是线程安全的，可以拿到懒加载的效果，同时是线程安全的；

代码实现：

package singleton.type7;

/**
 使用静态内部类完成单例模式
 */
public class SingLeton {

    //加上volatile关键字：可以让共享的变量达到共享的结果
    private static volatile SingLeton singleton;


    //构造器私有化
    private SingLeton(){

    }

    //静态内部类

    /**
     * 好处：外部类在装载的时候，并不会直接装载这个内部类，从而保证了懒加载是可用的；
     * 只有来取的时候，才会被装载；
     */
    private static class SingLetonInClass{
        private static final SingLeton SING_LETON = new SingLeton();
    }


    //提供一个静态的共有方法，直接返回`SingLetonInClass.SING_LETON`
    public static SingLeton getSingleton(){
        return SingLetonInClass.SING_LETON;
    }
}

测试代码：

package singleton.type7;

/**
 * 使用静态内部类完成单例模式
 */
public class SingletonTest07 {

    public static void main(String[] args) {
        System.out.println("使用静态内部类完成单例模式：");
        SingLeton singLeton1 = SingLeton.getSingleton();
        SingLeton singLeton2 = SingLeton.getSingleton();

        //测试创建的两个是否相等
        System.out.println(singLeton1 == singLeton2);//true

        //可以查看hashCode是否相同
        System.out.println("singLeton1="+singLeton1.hashCode());
        System.out.println("singLeton2="+singLeton2.hashCode());

    }
}

测试结果：

使用静态内部类完成单例模式：
true
singLeton1=1956725890
singLeton2=1956725890

测试也是没问题的

优缺点：

  • 1、这种方式采用了类装载的机制来保证初始化实例时只有一个线程；
  • 2、静态内部类方式在外部类SingLeton类被装载时，不会立即实例化。而是在需要实例化的时候，调用内部类的变了时，才会被装载，从而完成SingLeton类的实例化；
  • 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高；

结论：

避免了线程不安全，利用静态内部类特点实现延迟加载，效率高；

推荐使用；

七、枚举（推荐使用）

说明：

原先的一些问题，都可以使用枚举类来解决，用枚举类来实现单例模式还是比较好的。

代码实现：

package singleton.type8;

//使用枚举类实现单例模式
enum  SingLeton {

    SING_LETON;//属性

    public void getInfoData(String name){
        System.out.println("你好:"+name);
    }
}

测试代码：

package singleton.type8;

/**
 * 使用静态内部类完成单例模式
 */
public class SingletonTest07 {

    public static void main(String[] args) {
        System.out.println("使用枚举类实现单例模式：");

        SingLeton singLeton1 = SingLeton.SING_LETON;
        SingLeton singLeton2 = SingLeton.SING_LETON;

        //测试创建的两个是否相等
        System.out.println(singLeton1 == singLeton2);//true

        //可以查看hashCode是否相同
        System.out.println("singLeton1="+singLeton1.hashCode());
        System.out.println("singLeton2="+singLeton2.hashCode());

    }
}

测试结果：

使用枚举类实现单例模式：
true
singLeton1=1956725890
singLeton2=1956725890

测试结果也是成功的；

优缺点：

  • 使用枚举类的方式来实现单例模式，借助了JDK1.5中添加的枚举类来实现的。不仅能避免多线程同步问题，还能防止反序列化重新创建对象。

结论：

这种方式是Effective Java作者Josh Bloch提倡的方式；

推荐使用。

八、单例模式在JDK源码中使用的情形

在jdk源码中Runtime就使用了单例模式来实现的

在 java.lang.Runtime中

打开Runtime.java的源码的话，可以看到包含一下代码：

public class Runtime {
    private static Runtime currentRuntime = new Runtime();


    public static Runtime getRuntime() {
        return currentRuntime;
    }

  
    private Runtime() {}

 ......   
}

代码分析：

  • 1、构造方法是私有的：private Runtime(){};
  • 2、变量是最初new出来的：private static Runtime currentRuntime = new Runtime();;
  • 3、只有用到的时候是使用get方法获取的:getRuntime()；

由以上分析过后，可以看出来是使用的饿汉式的单例实现模式来实现的。

九、总结

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

推荐使用的实现单例模式的方式：

  • 枚举类
  • 静态内部类
  • 双重检查
  • 饿汉式（可能会存在内存浪费）

单例模式注意事项和细节说明：

  • 1、单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能；
  • 2、当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new；

单利模式使用的场景：

  • 1、需要频繁的进行创建和销毁的对象；
  • 2、创建对象时耗时过多或消耗资源过多（重量级对象）；
  • 3、经常用到的对象、工具类对象、频繁访问数据库或文件的对象（比如：数据源、session工厂等）。

作者博客首页：truedei.blog.csdn.net
文章原文地址：truedei.blog.csdn.net/article/det…
欢迎关注我，一起创造奇迹；代码改变世界，一点也没有错。

avatar
文章
阅读
粉丝