java设计模式之单例模式

最新推荐文章于 2025-06-06 14:48:34 发布

一只小小攻城狮

最新推荐文章于 2025-06-06 14:48:34 发布

阅读量163

点赞数

CC 4.0 BY-SA版权

分类专栏： java

本文链接：https://blog.csdn.net/weixin_45493751/article/details/101176000

java 专栏收录该内容

6 篇文章

订阅专栏

本文深入探讨了单例模式的两种实现方式：饿汉式和懒汉式。饿汉式采用积极加载，在类加载时就创建对象，适用于多线程且确保安全性。懒汉式采用延迟加载，仅在首次使用时创建对象，提高资源利用效率。文章通过具体代码示例，展示了不同场景下单例模式的应用。

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

单例模式.
饿汉式:(多线程程序是安全的:因为类只被加载一次,加载一次因为类加载器的全盘负责委托机制)
积极加载,意思就是不管你用不用,都会创建出来该对象!(类似于学校食堂)
延迟加载,也称为懒加载!(类似于小饭馆)
你不用不创建,你用才创建!
在一个程序中一个类只允许产生一个对象!!
如何能产生一个对象
1.不允许外界new对象,构造私有化!!
构造私有化之后我们无法获取对象那怎么办?
2.提供一个get功能获取single对象
这个方法是静态!!

饿汉式:(积极加载)

public class Single {

    private static Single single=new Single();

    //构造方法私有化
    private Single(){}

    public static Single newInstance() {
        return single;
    }
}

public class Demo {
    public static void main(String[] args) {
        Single single=Single.newInstance();
        Single single2=Single.newInstance();
        Single single3=Single.newInstance();
        Single single4=Single.newInstance();
        System.out.println(single);
        System.out.println(single2);
        System.out.println(single3);
        System.out.println(single4);
    }
}

程序结果如图:
可以看出,创建的对象都是同一对象,说明该类只被加载了一次.
在这里插入图片描述
饿汉式有个缺点:
就是这个对象不用也会被创建出来
想法就是我用的时候再创建
对象用的时候才创建

懒汉式(延迟加载):

public class Single {

    private static Single single;

    //构造方法私有化
    private Single() {
    }

    public static Single newInstance() {

        if (single==null){//没有new过
            single=new Single();
        }
        return single;
    }
}

public class Demo {
    public static void main(String[] args) {
        Single single = Single.newInstance();
        Single single2 = Single.newInstance();
        Single single3 = Single.newInstance();
        Single single4 = Single.newInstance();
        System.out.println(single);
        System.out.println(single2);
        System.out.println(single3);
        System.out.println(single4);
    }
}

在这里插入图片描述

懒汉式写法保证对象唯一(单线程中):

public class Single {

    private static Single single;

    //构造方法私有化
    private Single() {
    }

   public synchronized static Single newInstance(){
        if (single == null) {//判断是否要加锁
            synchronized (Single.class) {
                if (single == null) {//是否new过!
                    single=new Single();
                }
            }
        }
        return single;
    }
}

package com.itheima.lazysinglesynchronized;

public class MyThread extends Thread {

    @Override
    public void run() {

        for (int i = 0; i <4 ; i++) {
            Single single = Single.newInstance();

            System.out.println(single);
        }
    }
}

public class Demo {
    public static void main(String[] args) {

        //开启一个新的线程

        new MyThread().start();

        Single single = Single.newInstance();
        Single single2 = Single.newInstance();
        Single single3 = Single.newInstance();
        Single single4 = Single.newInstance();
        System.out.println(single);
        System.out.println(single2);
        System.out.println(single3);
        System.out.println(single4);
    }
}

在这里插入图片描述