单例模式学习

最新推荐文章于 2024-05-27 11:26:36 发布

欧尔瑞特

最新推荐文章于 2024-05-27 11:26:36 发布

阅读量56

点赞数

分类专栏：学习笔记

本文链接：https://blog.csdn.net/jo___jo/article/details/103091868

版权

学习笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

好好整理一下单例模式，拿下它

单例模式的作用

1、节省内存和计算2、保证结果正确3、方便管理

单例模式适用场景

1、无状态的工具类
2、全局信息类

单例模式8种写法

网上有很多版本，全部搜索下来有8种，其中也包括了很多不可用的方法，我会尽量把不可以用的理由写上去。
1、饿汉式（静态变量方法）

package com.Singleton;

//单例模式学习，饿汉式（静态常量）
public class Singleton1 {
    //第一步：创建实例,记得使用static，这样的话就在加载类的时候就装载好了实例，可以在第三步直接调用了。
    private final static Singleton1 singleton1 = new Singleton1();

    //第二步：私有构造函数
    private Singleton1() {

    }
    //第三步：创建共有获取方法
    public static Singleton1 getSingleton1(){
        return singleton1;
    }

}

2、饿汉式，静态代码块方法

package com.Singleton;

public class Singleton2 {
    //第一步：创建实例,记得使用static，这样的话就在加载类的时候就装载好了实例，可以在第三步直接调用了。
    private final static Singleton2 singleton2;

    static {
        singleton2 = new Singleton2();
    }

    //第二步：私有构造函数
    private Singleton2() {

    }
    //第三步：创建共有获取方法
    public static Singleton2 getSingleton1(){
        return singleton2;
    }
}

饿汉式的核心思想就是在构造函数前就把对象给静态实例化了，这俩种方法基本可以看做一样的，并且可用。
3、懒汉式，线程不安全，这种方法实际操作中是不可用的，因为在实际操作中，如果多个用户同时第一次调用，那么在该类还没有生成第一个实例前，系统可能会因为同时运行而生成多个实例，而生成多个实例就等于失败的创建单例模式了。
但是懒汉式的思想无疑是比饿汉式的超前的，既是当用户需要调用的时候我再产生实例。

package com.Singleton;
//懒汉式，线程不安全，不可用
public class Singleton3 {
    private static Singleton3 singleton3;
    private Singleton3(){
        
    }
    public static Singleton3 getSingleton3(){
        if (singleton3 == null) {
            singleton3 = new Singleton3();
            return singleton3;
        } else {
            return singleton3;
        }
    }
}

4、懒汉式，synchronized，然后就有人说，那么我加一个锁，它不就确保只有一个实例了么。确实，这样的确粗暴的保证了线程安全，但是因为加锁，每次调用该类都需要加锁解锁，会产生巨大的时间消耗，所以并不推荐使用

package com.Singleton;
//懒汉式，线程安全，不推荐用
public class Singleton3 {
    private static Singleton3 singleton3;
    private Singleton3(){
        
    }
    public synchronized Singleton3 getSingleton3(){
        if (singleton3 == null) {
            singleton3 = new Singleton3();
            return singleton3;
        } else {
            return singleton3;
        }
    }
}

5、这个时候因为效率低下的原因，有人想起关于锁代码块的方法，原理就是缩小锁的范围，以此减轻时间的消耗。但是实际运行中，这个方法被证明是错误的，原因是就算加了锁，只会让多个线程进入了获取的锁的等待池，只要进入了等到池，那么只要它拿到了锁，那就会再去创建多个实例，这个错误和方法三是一样的。

package com.Singleton;
//懒汉式，线程不安全，无法使用
public class Singleton3 {
    private static Singleton3 singleton3;
    private Singleton3(){
        
    }
    public static Singleton3 getSingleton3(){
        if (singleton3 == null) {
        synchronized(Singleton3.class){
            singleton3 = new Singleton3();
            return singleton3;
            }
        } else {
            return singleton3;
        }
    }
}

6、终于，这个时候有一些小伙伴想到了更好的办法，你说我加一个锁里面会有错误，那我再加一层判断，那总可以了吧，这就是已经比较成熟的双重检查法了。然后既然要做就要做的彻底，记得要给静态对象加上volatile，这样干脆把重排序和一些可见性问题也干脆解决了（可能影响不大，但是做事做到底），双重检查问题在实战中并不是最常用的，但无疑是面试中最常问的。

package com.Singleton;
//双重检查
public class Singleton3 {
    //加volatile更好
    private volatile static Singleton3 singleton3;
    private Singleton3(){
        
    }
    public static Singleton3 getSingleton3(){
    //第一次检查，如果实例为空，则进入锁代码块
        if (singleton3 == null) {
        synchronized(Singleton3.class){
        //第二次检查，进入了锁代码块，如果实例还为空，就再创建实例
          if(singleton3 == null){
            singleton3 = new Singleton3();
            return singleton3;
              }
            }
        } else {
            return singleton3;
        }
    }
}

7、最佳的实现方式，静态内部类写法。把创建实例的过程放入到了内部类当中。

package com.Singleton;
//静态内部类
public class Singleton4 {
    private Singleton4(){
        
    }
    private static class SingletonInstance{
        private static final Singleton4 SINGLETON_4 = new Singleton4();
    }
    public static Singleton4 getInstance(){
        return SingletonInstance.SINGLETON_4;
    }

8、新型的方式，枚举方式