栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

java中设计模式之单例模式之比较

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

java中设计模式之单例模式之比较

一、应用场景

各种manager
各种factory

定义:指一个类只有一个实例,且该类能自行创建这个实例的一种模式

单例模式的优点:
单例模式可以保证内存里只有一个实例,减少了内存的开销。
可以避免对资源的多重占用。
单例模式设置全局访问点,可以优化和共享资源的访问。

单例模式的缺点:
单例模式一般没有接口,扩展困难。如果要扩展,则除了修改原来的代码,没有第二种途径,违背开闭原则。
在并发测试中,单例模式不利于代码调试。在调试过程中,如果单例中的代码没有执行完,也不能模拟生成一个新的对象。
单例模式的功能代码通常写在一个类中,如果功能设计不合理,则很容易违背单一职责原则。

一、饿汉式(不管是不是用,先创建实例)

public class Mgr01 {
//    private static final Mgr01 INSTANCE;
//
//    static {
//        INSTANCE = new Mgr01();
//    } 同下面写法一样

    private static final Mgr01 INSTANCE = new Mgr01();

    // 构造方法设置为private,别人就无法new出对象,保证唯一入口,唯一对象
    // 只能通过Mgr01.getInstance()获得对象
    private Mgr01() {

    }

    private static Mgr01 getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) {
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        // m1==m2即代表是同一个实例
        System.out.println(m1 == m2);
    }
}

二、懒汉式(需要时再初始化)

public class Mgr02 {
    private static Mgr02 INSTANCE;

    private Mgr02() {

    }

    private static Mgr02 getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Mgr02();
        }
        return INSTANCE;
    }
}

为什么会带来线程问题,我们模拟下多线程场景看下:

public class Mgr03 {
    private static Mgr03 INSTANCE;

    private Mgr03() {

    }

    private static Mgr03 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() ->
                    //注意:不同实例的hashCode值是不同的
                    System.out.println(Mgr03.getInstance().hashCode())
            ).start();
        }
    }
}

运行结果如下:

966186071
733365800
966186071
544002391
118531371
966186071
930626000
1634218452
1650594751
1133046463
503674368
1326204679
。。。。

可以看出都是不同的实例的。
如何解决呢,我们可以在getInstance()方法前用synchronized关键词修饰,使线程同步,

public class Mgr04 {
    private static Mgr04 INSTANCE;

    private Mgr04() {

    }

    private static synchronized Mgr04 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr04();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() ->
                    //注意:不同实例的hashCode值是不同的
                    System.out.println(Mgr04.getInstance().hashCode())
            ).start();
        }
    }
}

运行结果如下:

1650373908
1650373908
1650373908
1650373908
1650373908
1650373908
。。。

可以看到都是同一实例,保证了线程的安全,不过会使性能下降。

那如何提高效率呢:

public class Mgr05 {
    private static Mgr05 INSTANCE;

    private Mgr05() {

    }

    private static Mgr05 getInstance() {
        if (INSTANCE == null) {
            // 试图通过减小同步代码块的方式提高效率,但是不可行
            synchronized (Mgr05.class) {
                try {
                    Thread.sleep(10);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                INSTANCE = new Mgr05();
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() ->
                    //注意:不同实例的hashCode值是不同的
                    System.out.println(Mgr05.getInstance().hashCode())
            ).start();
        }
    }
}

运行结果后我们发现并不可行,也是不安全的,那么我们双重上锁看看:

public class Mgr06 {
    private static Mgr06 INSTANCE;

    private Mgr06() {

    }

    private static Mgr06 getInstance() {
        if (INSTANCE == null) {
            // 双重检查是否为空
            synchronized (Mgr06.class) {
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(10);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() ->
                    //注意:不同实例的hashCode值是不同的
                    System.out.println(Mgr06.getInstance().hashCode())
            ).start();
        }
    }
}

运行结果后发现是可以的,这种方式显得有点复杂,但是确实比较完美了,但还有更完美的方式如下:

public class Mgr07 {
    private Mgr07() {

    }

    private static class Mgr07Holder {
        private static final Mgr07 INSTANCE = new Mgr07();
    }

    public static Mgr07 getInstance() {
        return Mgr07Holder.INSTANCE;
    }


    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(() ->
                    //注意:不同实例的hashCode值是不同的
                    System.out.println(Mgr07.getInstance().hashCode())
            ).start();
        }
    }
}
总结

其实在实际开发过程中用Mgr01的方式实现单例即可,虽然有些小问题,但完全可以满足使用,如果想要吹毛求疵,写的完美,那就选择Mgr06或者Mgr07的方式了。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/981446.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号