Java设计模式-单例模式

最新推荐文章于 2022-02-16 12:31:34 发布
最新推荐文章于 2022-02-16 12:31:34 发布
阅读量287 收藏
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式 java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35415600/article/details/108765578
版权

设计模式-8种单例模式

第一种：饿汉式-1

package com.liuxd.singleton;

/**
 * @description：
 * 单例设计模式
 * 饿汉式
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全
 * 简单实用，推荐使用。
 * 唯一缺点：不管用到与否，类装载时就完成实例化
 *
 * @author: liuxd
 * @date: 2020/9/24 00:52
 */
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) {
        for(int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(Mgr01.getInstance().hashCode());
            }).start();
        }
    }
}

第二种：饿汉式-2

package com.liuxd.singleton;

/**
 * @description：
 * 跟01是一个意思
 *
 * @author: liuxd
 * @date: 2020/9/24 00:52
 */
public class Mgr02 {
    private static 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) {
        for(int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(Mgr02.getInstance().hashCode());
            }).start();
        }
    }
}

第三种：懒汉式-多线程不安全

package com.liuxd.singleton;

/**
 * @description：
 * 单例设计模式
 * 懒汉式
 * 虽然达到了按需初始化的目的， 但却带来了多线程不安全的问题
 *
 * @author: liuxd
 * @date: 2020/9/24 00:52
 */
public class Mgr03 {
    private static Mgr03 INSTANCE;

    private Mgr03(){}
    /*
    多线程不安全问题解释：
    当A线程执行if(INSTANCE==null){时，由于休眠1毫秒，还未执行到INSTANCE=new Mgr03();
    此时B线程也开始执行if(INSTANCE==null){时，发现INSTANCE为空，也开始向下执行INSTANCE=new Mgr03();
    最终A、B线程拿到的的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++){
            new Thread(()->{
                System.out.println(Mgr03.getInstance().hashCode());
            }).start();
        }
    }
}

第四种：懒汉式-多线程安全

package com.liuxd.singleton;

/**
 * @description： 单例设计模式
 * 懒汉式
 * 虽然达到了按需初始化的目的， 解决了多线程不安全的问题
 * <p>
 * 可以通过在getInstance方法上加锁synchronized解决，但也带来了效率下降
 * @author: liuxd
 * @date: 2020/9/24 00:52
 */
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();
        }
    }
}

第五种：懒汉式-多线程不安全

package com.liuxd.singleton;

/**
 * @description： 单例设计模式
 * 懒汉式
 * <p>
 * 可以通过在getInstance方法中的if方法块加锁synchronized解决，但却带来了多线程不安全的问题
 * @author: liuxd
 * @date: 2020/9/24 00:52
 */
public class Mgr05 {
    private static Mgr05 INSTANCE;

    private Mgr05() {
    }

    public static Mgr05 getInstance() {
        if (INSTANCE == null) {
            /*
            试图通过减少同步代码块的方式，提高效率，但是存在多线程安全问题。
            A、B线程进入if判断里，A线程还未拿到锁，B线程已经拿到锁，A线程进入阻塞状态。
            B线程拿到锁后，获取到实例，并且释放锁；此时A线程再获取到锁，再获取一个新的实例。
            此时A、B线程创建了两个不同的实例。出现多线程不安全问题。
             */
            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();
        }
    }
}

第六种：懒汉式-多线程安全

package com.liuxd.singleton;

/**
 * @description： 单例设计模式
 * 懒汉式
 * <p>
 * 双重检查
 * @author: liuxd
 * @date: 2020/9/24 00:52
 */
public class Mgr06 {
    //加上volatile，防止指令重排问题 JIT
    private static volatile Mgr06 INSTANCE;

    private Mgr06() {
    }

    public static Mgr06 getInstance() {
         /*
            双重检查，解决了多线程安全问题
            A、B线程进入if判断里，A线程还未拿到锁，B线程已经拿到锁，A线程进入阻塞状态。
            B线程拿到锁后，先判断实例是否为空，此时为空创建实例，并且释放锁；
            A线程拿到锁后，先判断实例是否为空，此时不为空，则返回原实例，并且释放锁；
            此时A、B线程获得到的是同一个实例。解决了多线程安全问题。
             */
        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();
        }
    }
}

第七种：静态内部类方式

package com.liuxd.singleton;

/**
 * @description： 单例设计模式
 * <p>
 * 静态内部类方式
 * JVM保证单例
 * 加载外部类时不会加载内部类，这样可以实现懒加载
 * @author: liuxd
 * @date: 2020/9/24 00:52
 */
public class Mgr07 {

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

    public static Mgr07 getInstance() {
        return Mgr07Handler.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();
        }
    }
}

第八种：枚举方式

package com.liuxd.singleton;

/**
 * @description： 单例设计模式
 * <p>
 * 不仅可以解决线程同步，还可以防止反序列化
 * @author: liuxd
 * @date: 2020/9/24 00:52
 */
public enum Mgr08 {

    INSTANCE;
    public static Mgr08 getInstance() {
        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(Mgr08.getInstance().hashCode());
            }).start();
        }
    }
}
YI_DIAN_DIAN
关注
专栏目录
Java设计模式-单例模式详解
11-24
Java设计模式-单例模式详解 单例模式是 Java 设计模式中的一种常用的设计模式，旨在保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例模式的目的是为了保证在一个进程中，某个类有且仅有一个实例。 ...
单例模式之饿汉式
ganmaotong的博客
03-06 2765
饿汉式单例这种方式简单，也比较常用，在类创建的同时已经创建好一个静态的对象供系统使用，执行效率高。但这种方式下，因为还未调用对象就已经创建，造成资源的浪费，容易产生垃圾对象。
5. 单例模式
hanzong110的博客
03-19 122
5 单例模式 确保一个类只有一个实例，并提供一个全局访问点 5.1 应用场景 线程池、缓存、注册表等只能有一个实例的对象 5.2 代码 饿汉式 package com.mashibing.dp.singleton; /** * 饿汉式 * 类加载到内存后，就实例化一个单例，JVM保证线程安全 * 简单实用，推荐使用！ * 唯一缺点：不管用到与否，类装载时就完成实例化 * Class...
设计模式 - 单例设计模式（饿汉式）
爱写BUG的羽毛
06-04 485
package com.plumage.designpattern; /** * @author 羽毛 * @description 单例设计模式 - 饿汉式 */ public class MyHungrySingleton { private MyHungrySingleton hungrySingleton; private MyHungrySingleton() { //私
单例设计模式之饿汉式和懒汉式
weixin_39039345的博客
11-23 5167
1.设计模式？ 设计模式是在大量的实践中总结和理论化之后优选的代码结构,编程风格,以及解决问题的思考方式。 2.单例模式的概念？     单例模式，我们首先必须将类在一个虚拟机中只能产生一个对象，因此应该做到以下几步：a:私有化构造方法，这样在该类的外边就不能用new操作来创建对象，但是在类的内部可以创建该类的对象。b:调用该类的某个静态方法以返回内部创建的对象，因为该类的外部不发得到创建的
Singleton 单例模式
yw_2022的博客
02-16 170
Singleton 单例模式
java设计模式-单例.pdf
最新发布
05-16
### Java设计模式——单例模式详解 #### 一、单例模式概述 单例模式是设计模式中的一个重要组成部分，属于创建型模式之一。其主要作用是确保某个类仅有一个实例存在，并提供一个全局访问该实例的方法。这在很多场景...
JAVA-设计模式-创建型模式-单例模式
08-10
JAVA-设计模式-创建型模式-单例模式
ava常用设计模式-单例模式
08-26
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，有以下特点： 1. 单例类只能有一个实例。 2. 单例类必须自己创建自己的唯一实例。 3. 单例类必须给所有其他对象提供这一实例。 单例模式有多种实现...
java设计模式-单例模式
02-27
设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段...
设计模式系列之 单例模式
灯塔的CSDN博客
05-09 936
单例模式 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 1、单例类只能有一个实例。 2、单例类必须自己创建自己...
java 单例模式 ---饿汉式懒汉式
小何同学~
01-28 5394
目录 单例设计模式 饿汉式 懒汉式 饿汉式vs懒汉式 结语 单例设计模式 所谓单例设计模式，就是采取一定的方法在整个软件系统中，对某个类只能存在一个对象实例 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实例。 饿汉式 饿汉式：在程序启动或单例模式类被加载的时候，单例模式实例就已经被创建。 上例子！ package com.happy.demo; public class Singleton...
设计模式-单例模式-饿汉式单例和懒汉式单例
oneleo_的博客
12-29 1728
  单例模式（Singleton pattern）一个在设计模式中比较简单的模式，我们常说的饿汉式和懒汉式是最常举例的两种写法。 如下 饿汉式：   public class Singleton { private static final Singleton singleton = new Singleton(); //限制产生多个对象 private Singleton(){...
单例模式（Singleton）
wuychn
03-15 4912
单例模式保证类在内存中只有一个实例。 饿汉式 所谓饿汉式，就是在类加载的时候就创建实例： public class Singleton { // 1、构造方法私有化 private Singleton() { } // 2、实例化私有静态对象 private static Singleton instance = new Singleton();...
单例设计模式的设计——饿汉模式
Running-小猛的博客
01-09 202
package SingleInstanceModel; /** * Created by JYM on 2019/1/8 * 单例模式下的：饿汉模式 * */ //final不允许被继承 public final class Singleton {     //实例变量     private byte[] data = new byte[1024];     //在定义实例对象的时候直接初...
java单例设计模式--饿汉模式
10-25 321
在编程时我们经常遇到一些经典的问题或者需要完成某种特定需求设计模式就是针对这些问题和需求，在大量实践中总结优选的代码结构和编写风格解决问题的思考方式，设计模式就行棋谱，不同的棋局，我们需要不同的解决方式。 单例模式是java中的一种设计模式，它是指在设计一个类时，需要保证整个过程只存在一个实例对象。就像我们生存的世界上只有一个月亮。 饿汉模式： class Single1{ /*
第五篇 设计模式--饿汉单例模式
naivor的专栏
02-03 475
单例模式定义：保证一个类只有一个实例，并提供一个访问它的全局访问点。 饿汉单例：在类被加载时就创建。 好处：提供对唯一实例的受控访问，节约系统内存资源，解决在多线程中懒汉单例无法做到保证一个类只有一个实例的情况。 package singleton.hungrysingleton; /** * @author naivor * 饿汉单例模式-场景类 */ public cl
设计模式系列（6）饿汉式单例模式
洪流之源
03-30 343
饿汉式单例模式与懒汉式单例模式差别不大，只需要修改很少的代码，改动的代码用红色标注： #include using namespace std; class Singleton { private: Singleton() { m_singler = NULL; m_count = 0; cout << "构造函数 Singlton...do" <
设计模式之单例模式四（饿汉式）
Wenlong_L的博客
09-19 2767
前面讲了懒汉式的单例模式，所谓懒汉式就是延迟加载，什么时候需要什么时候构造。前面的博客中讲了两种实现方法。第一种懒汉式的实现是在getInstance中直接new一个单例对象，这种实现方法就得自己考虑线程安全而加锁，具体加锁的实现也讲了两种方法，一种是基于同步方法；另一种是采用double check的方法。第二种懒汉式的实现是采用私有静态内部类的方式进行延迟加载，让单例对象在内部类的初始化阶段进...
聊聊设计模式-单例模式
09-29
单例模式是一种创建型设计模式，它保证类仅有一个实例，并提供一个全局访问点。在单例模式中，类会自行创建一个实例，并对外提供一个访问该实例的方法。 单例模式有多种实现方式，其中常见的有懒汉式和饿汉式。懒汉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值