手撕单例模式--饿汉式与懒汉式

最新推荐文章于 2024-12-03 15:45:09 发布

原创最新推荐文章于 2024-12-03 15:45:09 发布 · 314 阅读

1 ·

CC 4.0 BY-SA版权

JavaSE 专栏收录该内容

9 篇文章

订阅专栏

本文介绍了单例模式的概念、优点，并详细讲解了饿汉式和懒汉式单例的实现及区别。饿汉式在类加载时就创建实例，线程安全但可能浪费资源；懒汉式则是用时创建，首次使用时可能存在线程安全问题，可通过双重检查锁定解决。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、什么是单例模式

1.概念：单例模式指的是在应用整个生命周期内只能存在一个实例。

a.对象如何产生？ ----------------- 通过类的构造方法

b.如何限制对象的产生？----------- 通过构造方法限制

2.优点：能够避免实例对象的重复创建，减少创建实例的系统开销，节省内存

3.特点：1.单例类只能有一个实例。2.单例类必须自己自己创建自己的唯一实例。3.单例类必须给所有其他对象提供这一实例。

二、单例模式

1.饿汉式单例

所谓饿汉模式就是立即加载，也就是在类加载的时候已经产生了。这种方式适合占用资源少，在初始化的时候就会被用到的类。

//饿汉式单例
class Singlerton{
    //1.构造方法私有化，类外部无法产生实例化对象
    private Singlerton(){}
    //2.类内部提供实例化对象，类外部无法改变，所有声明为全局常量
    private static final Singlerton sg = new Singlerton();
    //3.通过getter（）方法取得类内部的私有化
    public static Singlerton getSinglerton(){
        return sg;
    }
}

但是以上实现没有考虑线程安全问题。

所谓线程安全是指：如果代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

显然以上实现并不满足线程安全的要求，在并发环境下很可能出现多个Singleton实例。

2.懒汉式单例：用时再new

懒汉模式就是延迟加载，也叫懒加载。在程序需要用到的时候再创建实例，这样保证了内存不会被浪费。

//懒汉式单例
//多线程下不安全：
class Singlerton2{
    //1.构造方法私有化，类外部无妨访问，限制了对象的产生
     private Singlerton2(){}
    //2.类内部提供实例化对象，类外部无法改变，所有声明为全局常量
     private static Singlerton2 sg2;
    //3.通过getter方法取得类内部的私有化
     public static Singlerton getSinglerton(){
         if (sg2==null){
            sg2 = new Singlerton2();
         }
         return sg2;
    }
}

//多线程下安全：
class Singleton{
    private Singleton(){}
    private static volatile Singleton sin;
    public static Singleton get(){
        if(sin==null){
            synchronized(Singleton.class){
                if(sin==null){
                    sin = new Singleton();
                }
            }
        }
        return sin;
    }
}

2.1 普通的懒汉式单例：单线程下没有问题，多线程下会出现问题

class Singlerton{
    private static Singlerton sin;
    private Singlerton(){}
    public static Singlerton getSin(){
        if(sin==null){
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sin = new Singlerton();
        }
        return sin;
    }
}
public class SinglertonTest {
    public static void main(String[] args) {
        //单线程下：
/**
        System.out.println(Singlerton.getSin().hashCode());
        System.out.println(Singlerton.getSin().hashCode());
        System.out.println(Singlerton.getSin().hashCode());
        System.out.println(Singlerton.getSin().hashCode());
        System.out.println(Singlerton.getSin().hashCode());
        System.out.println(Singlerton.getSin().hashCode());
        System.out.println(Singlerton.getSin().hashCode());
        System.out.println(Singlerton.getSin().hashCode());
        System.out.println(Singlerton.getSin().hashCode());
*/
        //多线程下：
        for(int i=0; i<10; i++) {
            new Thread(()-> {
                System.out.println(Singlerton.getSin().hashCode());
            }).start();
        }
    }
}

结果：单线程：多线程：

举个栗子：现在有3个票贩子卖明星的演唱会门票，现在票贩子b和票贩子c手中的官网显示还有1张票，都想高价卖出去，现在票贩子c找到一个买家，同时b也找到一个买家，他们同时售卖，同时进行交易，就造成了1张票卖出去2次，这就是多线程下可能会出现的问题。

显然，对于上面写的单例，说明在多线程环境下，产生了多个对象，不符合单例模式的要求

2.2 双重加锁下的懒汉式单例：

class Singlerton{
    private static Singlerton sin;
    private Singlerton(){}
    public static Singlerton getSin(){
        if(sin==null){
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (Singlerton.class) {
                if (sin == null) {
                    sin = new Singlerton();
                }
            }
        }
        return sin;
    }
}
public class SinglertonTest {
    public static void main(String[] args) {
        //多线程
        for(int i=0; i<10; i++) {
            new Thread(()-> {
                System.out.println(Singlerton.getSin().hashCode());
            }).start();
        }
        //单线程
//        System.out.println(Singlerton.getSin().hashCode());
//        System.out.println(Singlerton.getSin().hashCode());
//        System.out.println(Singlerton.getSin().hashCode());
//        System.out.println(Singlerton.getSin().hashCode());
//        System.out.println(Singlerton.getSin().hashCode());
//        System.out.println(Singlerton.getSin().hashCode());
//        System.out.println(Singlerton.getSin().hashCode());
//        System.out.println(Singlerton.getSin().hashCode());
//        System.out.println(Singlerton.getSin().hashCode());
    }
}

结果：多线程：单线程：