设计模式---单例模式

魏玉柱java

已于 2022-06-16 11:06:54 修改

阅读量96

点赞数

分类专栏：笔记文章标签： java

于 2022-06-15 16:14:11 首次发布

本文链接：https://blog.csdn.net/weixin_55547115/article/details/125299283

版权

笔记专栏收录该内容

29 篇文章 0 订阅

订阅专栏

1.饿汉式

类加载到内存后，就实例一个单例，JVM保证线程的安全
简单实用，推荐使用。
唯一缺点：不管用到与否，类装载时就完成实例化
（话说你不用的，不装他干嘛）

public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01() {};

    public static Mgr01 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1 == m2);
    }
}

2.饿汉式1.2

和上面的01是一样的原理，只是在new的工作
放到下面进行写，静态代码块也是执行比较早的
目录

public class Mgr02 {
    private static final Mgr02 INSTANCE;
    static {
        INSTANCE = new Mgr02();
    }

    private Mgr02() {};

    public static Mgr02 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Mgr02 m1 = Mgr02.getInstance();
        Mgr02 m2 = Mgr02.getInstance();
        System.out.println(m1 == m2);
    }
}

3.懒汉式

懒汉式虽然达到按需最初的效果，但却带来线程不安全的问题
我们知道懒汉式的单例模式，创建对象的时机在第一次调用getInstance（）方法。
而安全隐患就存在这时间段，倘若有两条线程都是运行该代码段，
一条线程运行过程进入了if语句块且
还没有把创建对象的实例赋值给成员变量时恰好进入了阻塞状态
（还不清楚线程生命周期的小伙伴可理解为该线程暂停了）。
由于if语句判断条件依据是：instance == null才能进入该语句块
那么另一条线程就有可能会混进在该if语句块，
最后就会导致两个线程创建了两个不一样的对象。

public class Mgr03 {
    private static Mgr03 INSTANCE;

    private Mgr03() {
    }

    public static Mgr03 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            //同一个类的不同实例的hashCode是不一样的
            //如果不是同一个类的实例对象，hashCode有可能一样
            new Thread(()->
                System.out.println(Mgr03.getInstance().hashCode())
            ).start();
        }

//        Mgr03 m1 = Mgr03.getInstance();
//        Mgr03 m2 = Mgr03.getInstance();
//        System.out.println(m1 == m2);
    }
}

3.1懒汉式

懒汉式
虽然达到了按需初始化的需，但是出现了线程不安全的问题
可以通过synchronized进行处理，同时也带来问题效率下降

public class Mgr04 {
    private static Mgr04 INSTANCE;

    private Mgr04() {
    }

    public static synchronized Mgr04 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr04();
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr04.getInstance().hashCode());
            }).start();
        }
    }
}

3.2懒汉式

懒汉式
虽然达到了按需初始化的需，但是出现了线程不安全的问题
可以通过synchronized进行处理，同时也带来问题效率下降
妄图通过减小同步代码块的方式提高效率，然后不可行

public class Mgr05 {
    private static Mgr05 INSTANCE;

    private Mgr05() {
    }

    public static Mgr05 getInstance() {
        if (INSTANCE == null) {

            //妄图通过减小同步代码块的方式提高效率，然后不可行

            synchronized (Mgr05.class) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Mgr05();
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr05.getInstance().hashCode());
            }).start();
        }
    }
}

3.3懒汉式

虽然达到了按需初始化的需，但是出现了线程不安全的问题
可以通过synchronized进行处理，同时也带来问题效率下降
通过采用双重验证的方法进行验证尝试提高效率
但无果

+public class Mgr06 {
    private static volatile Mgr06 INSTANCE; //JIT

    private Mgr06() {
    }

    public static Mgr06 getInstance() {

            //第一重检查
        if (INSTANCE == null) {

            //第二重检查
            synchronized (Mgr06.class) {
                if(INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

4.静态内部类方式

JVM保证单例
加载外部类时不会加载内部类，这样可以实现懒加载
静态内部类不会随着类的加载而进行加载，而是需要单独的加载和初始化

  private Mgr07() {
    }

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

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

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr07.getInstance().hashCode());
            }).start();
        }
    }


}

5.枚举单例

不仅可以解决线程同步，还可以防止反序列化。

public enum Mgr08 {

    INSTANCE;

    public void m() {}

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr08.INSTANCE.hashCode());
            }).start();
        }
    }

}

魏玉柱java

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
设计模式---单例模式

目录1.饿汉式2.饿汉式1.23.懒汉式3.1懒汉式3.2懒汉式3.3懒汉式4.静态内部类方式5.枚举单例2.饿汉式1.2 和上面的01是一样的原理，只是在new的工作放到下面进行写，静态代码块也是执行比较早的目录3.懒汉式懒汉式虽然达到按需最初的效果，但却带来线程不安全的问题我们知道懒汉式的单例模式，创建对象的时机在第一次调用getInstance（）方法。而安全隐患就存在这时间段，倘若有两条线程都是运行该代码段，一条线程运行过程进入了if语句块且还没
复制链接

扫一扫