java之单例模式

最新推荐文章于 2024-03-31 15:33:20 发布
最新推荐文章于 2024-03-31 15:33:20 发布
阅读量111 收藏
点赞数
分类专栏： java设计模式与多线程 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ITCSDN_/article/details/106982951
版权

单例模式

单例设计

一 ：基本介绍

  所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例， 并且该类只提供一个取得其对象实例的方法(静态方法)。
  比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够，这时就会使用到单例模式。

二：实现单例设计模式八种方式

  1. 饿汉式(静态常量，线程安全)
  2. 饿汉式(静态代码块，线程安全）
  3. 懒汉式(线程不安全)
  4. 懒汉式(线程安全，同步方法)
  5. 懒汉式(线程安全，同步代码块)
  6. 双重检查
  7. 静态内部类
  8. 枚举

饿汉式

 一：饿汉式(静态常量)

 1. 代码实现

public class SingletonTest01{
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());

        //测试线程安全：
        ExecutorService threadPool = Executors.newFixedThreadPool(20);

        for (int i = 0; i < 20; i++) {
            threadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + Singleton.getInstance());
                }
            });
        }

    }
}

class Singleton {

    //1. 构造器私有化,  外部能new
    private Singleton() {

    }

    //2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();

    //3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

测试结果如下：
在这里插入图片描述

 2. 总结

（1）优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
（2）缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。
（3）这种方式基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstance 方法， 但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 就没有达到 lazy loading 的效果。
（4） 结论：这种单例模式可用，可能造成内存浪费。

 二：饿汉式(静态代码块)

 1. 代码实现：

public class SingletonTest02 {
    public static void main(String[] args) {
        //测试
        Singleton1 instance = Singleton1.getInstance();
        Singleton1 instance2 = Singleton1.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}

class Singleton1 {
    //1. 构造器私有化,  外部能new
    private Singleton1() {

    }

    //2.本类内部创建对象实例
    private static Singleton1 instance;

    static { // 在静态代码块中，创建单例对象
        instance = new Singleton1();
    }

    //3. 提供一个公有的静态方法，返回实例对象
    public static Singleton1 getInstance() {
        return instance;
    }

}

测试结果如下：
在这里插入图片描述

 2. 总结

（1） 这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。
（2）结论：这种单例模式可用，但是可能造成内存浪费

懒汉式

 一：懒汉式(线程不安全)

 1. 代码实现

public class SingletonTest03{

    public static void main(String[] args) {
        System.out.println("懒汉式，线程不安全");
//        Singleton instance = Singleton.getInstance();
//        Singleton instance2 = Singleton.getInstance();
//        System.out.println(instance == instance2); // true
//        System.out.println("instance.hashCode=" + instance.hashCode());
//        System.out.println("instance2.hashCode=" + instance2.hashCode());

        //测试线程安全：
        ExecutorService threadPool = Executors.newFixedThreadPool(20);

        for (int i = 0; i < 20; i++) {
            threadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + Singleton03.getInstance());
                }
            });
        }
    }

}

class Singleton03 {
    private static Singleton03 instance;

    private Singleton03() {
    }

    //提供一个静态的公有方法，当使用到该方法时，才去创建 instance
    //即懒汉式
    public static Singleton03 getInstance() {
        if (instance == null) {
            instance = new Singleton03();
        }
        return instance;
    }
}

测试结果如下：
在这里插入图片描述
由图可以看出：存在多个实例的情况。

 2. 总结

（1）起到了 Lazy Loading 的效果，但是只能在单线程下使用。
（2） 如果在多线程下，一个线程进入了 if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式
（3） 结论：在实际开发中，不要使用这种方式.

 二：懒汉式(线程安全，同步方法)

 1. 代码实现

public class SingletonTest04 {
    public static void main(String[] args) {
        System.out.println("懒汉式，线程安全");
        Singleton04 instance = Singleton04.getInstance();
        Singleton04 instance2 = Singleton04.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());

        //测试线程安全：
        ExecutorService threadPool = Executors.newFixedThreadPool(20);
        for (int i = 0; i < 20; i++) {
            threadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + Singleton01.getInstance());
                }
            });
        }
    }
}

// 懒汉式(线程安全，同步方法)
class Singleton04 {
    private static Singleton04 instance;

    private Singleton04() {
    }

    //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    //即懒汉式
    public static synchronized Singleton04 getInstance() {
        if (instance == null) {
            instance = new Singleton04();
        }
        return instance;
    }
}

测试结果：
在这里插入图片描述

 2. 总结

（1）解决了线程安全问题。
（2）方法进行同步效率太低。
（3）结论：在实际开发中，不推荐使用这种方式。

 三：懒汉式(线程安全，同步代码块)

 1. 代码实现

public class SingletonTest05 {
    public static void main(String[] args) {
        Singleton05 instance = Singleton05.getInstance();
        Singleton05 instance2 = Singleton05.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());

        //测试线程安全：
        ExecutorService threadPool = Executors.newFixedThreadPool(20);

        for (int i = 0; i < 20; i++) {
            threadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + Singleton05.getInstance());
                }
            });
        }

    }
}

class Singleton05 {
    private static Singleton05 instance;

    private Singleton05() {
    }

    //提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    //即懒汉式
    public static Singleton05 getInstance() {
        if (instance == null) {
            synchronized (Singleton05.class) {
                instance = new Singleton05();
            }
        }
        return instance;
    }
}

测试结果如下，都是拿到同一个实例对象：
在这里插入图片描述

 2. 总结

（1）解决了线程安全的问题。
（2）效率低，开发时不考虑使用。

双重检查

 1. 代码实现

public class DoubleCheck {
    public static void main(String[] args) {
        System.out.println("双重检查");
        Singleton06 instance = Singleton06.getInstance();
        Singleton06 instance2 = Singleton06.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());

        //测试线程安全：
        ExecutorService threadPool = Executors.newFixedThreadPool(20);

        for (int i = 0; i < 20; i++) {
            threadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + Singleton06.getInstance());
                }
            });
        }

    }
}

class Singleton06 {
    private static volatile Singleton06 instance;

    private Singleton06() {
    }

    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
    //同时保证了效率, 推荐使用
    public static synchronized Singleton06 getInstance() {
        if (instance == null) {
            synchronized (Singleton06.class) {
                if (instance == null) {
                    instance = new Singleton06();
                }
            }
        }
        return instance;
    }
}

测试结果如下，都是拿到同一个实例对象：
在这里插入图片描述

 2. 总结

（1）Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null)检查，这样就可以保证线程安全了。
（2） 这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接 return 实例化对象，也避免的反复进行方法同步。
（3）线程安全；延迟加载；效率较高。
（4）结论：在实际开发中，推荐使用这种单例设计模式。

静态内部类

 1. 代码实现

public class StaticInnerClass {
    public static void main(String[] args) {
        System.out.println("使用静态内部类完成单例模式");
        Singleton07 instance = Singleton07.getInstance();
        Singleton07 instance2 = Singleton07.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());

        //测试线程安全：
        ExecutorService threadPool = Executors.newFixedThreadPool(20);

        for (int i = 0; i < 20; i++) {
            threadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":" + Singleton07.getInstance());
                }
            });
        }
    }
}

// 静态内部类完成， 推荐使用
class Singleton07 {
    private static volatile Singleton07 instance;

    //构造器私有化private Singleton() {}
    //写一个静态内部类,该类中有一个静态属性 Singleton
    private static class SingletonInstance {
        private static final Singleton07 INSTANCE = new Singleton07();
    }

    //提供一个静态的公有方法，直接返回 SingletonInstance.INSTANCE
    public static synchronized Singleton07 getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

测试结果如下，都是拿到同一个实例对象：
在这里插入图片描述

 2. 总结

（1）这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
（2）静态内部类方式在 Singleton 类被装载时并不会立即实例化，而是在需要实例化时，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化。
（3）类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
（4）优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
（5）结论：推荐使用.

枚举

 1. 代码实现

public class Enumerate {
    public static void main(String[] args) {
        Singleton08 instance = Singleton08.INSTANCE;
        Singleton08 instance2 = Singleton08.INSTANCE;
        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
}

//使用枚举，可以实现单例, 推荐
enum Singleton08 {
    INSTANCE; //属性

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

测试结果如下：
在这里插入图片描述

 2. 总结

（1）这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
（2）这种方式是 Effective Java 作者 Josh Bloch 提倡的方式。
（3）结论：推荐使用.
单例模式就这样 结束喽

 楠哥-------一个一心想为IT行业添砖加瓦，却总是面向cv编程的程序员。

   谢谢阅读，无误点赞，有误评论区指正。

楠哥学IT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式-单例模式
04-05
设计模式-单例模式 学习时候联系的代码，可以进行参考
java单例模式
qq_48268296的博客
07-09 3964
定义：单例模式（Singleton）指一个类只有一个实例，并且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。单例类只有一个实例对象；该单例对象必须由单例类自行创建；单例类对外提供一个访问该单例的全局访问点；
Java中的单例模式
Luke Ewin的博客
07-11 157
Java中的单例模式是Java面试中经常被问到的设计模式之一，单例模式在Java实际开发中经常用到，比如，我们需要日志功能，日志的实例就是单例的，整个系统中只存在一个日志对象。
Java 单例模式
kangk123456的博客
05-28 2485
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实例。 ...
Java单例模式
weixin_44545597的博客
07-07 106
Java中的单例模式
Java之单例模式&&NIO
12-22
Java中的单例模式是一种设计模式，它用于保证一个类只有一个实例，并提供一个全局访问点。在给定的代码示例中，我们看到了两种常见的单例实现方式：懒汉式和饿汉式。 **懒汉式单例模式**： 懒汉式单例的特点是延迟...
JAVA设计模式之单例模式
09-22
单例模式是软件设计模式中的一种经典模式，它在Java编程中被广泛使用，尤其是在需要控制实例化过程，或者确保某类只有一个实例时。本文将深入探讨Java中的单例模式，帮助你理解其原理和应用。 单例模式的核心思想是...
Java单例模式简单示例
08-30
Java单例模式简单示例 Java单例模式是一种非常常用的设计模式，它可以确保某个类只有一个实例，并提供一个全局访问点。下面我们将通过一个简单的示例来介绍Java单例模式的定义和使用技巧。 单例模式的定义 单例...
java单例模式及实现
09-22
Java单例模式及实现 Java单例模式是一种常见的设计模式，确保某一个类只有一个实例，而且向这个系统提供这个实例。单例模式可以分为三种：懒汉式单例、饿汉式单例、登记式单例。 单例模式的要点 1. 某个类只能有...
单例模式各种实现方式
03-26
java单例模式的实现方式
Java-单例模式
qq_36138652的博客
04-02 304
介绍: 确保某个类只有一个实例,而且自行实例化,并向整个系统提供这个实例 单例模式的三个要点: 某个类只能有一个实例 必须自行创建这个实例 必须自行向整个系统提供这个实例 包含角色: 单例模式只包含一个单例角色. 创建过程注意点: 提供一个自身私有的静态成员变量 单例类的构造函数为私有 提供一个公有的静态工厂方法 分类: 懒汉模式 饿汉模式 图: 代码: //懒汉模式 public class LazySingletons { private static La
java单例设计模式
专栏
04-08 2563
单例设计模式
单例模式（java）
qq_41170378的博客
04-06 1280
注：本文转自码农翻身微信ID:coderising介绍信息工作15年的IBM软件架构师分享编程和职场的经验和教训， 不容错过。二维码 码农翻身前言：本文原作者是王钦誉，原文链接：https://xiaoqinyu0000.github.io/Java/JavaSingleton/之前王钦誉还写过《Java帝国之拨云见日识回调》。  这篇文章很长，讲了单例模式的方方面面， 建议认真读完。1背景在Ja...
java设计模式-单例模式
沐晨~的博客
07-22 1742
1、单例模式的定义 单例模式顾名思义就是一个类只能拥有一个实例，这样保证对象的一致性。 2、单例模式的特点 1、单例类只能有一个实例 2、单例类必须自己创建自己的唯一实例 3、单例类必须给其他的对象提供这个实例 3、线程安全问题 1、首先不管是饱汉式还是饿汉式的单例模式，都必须将对象的构造方法进行私有化，避免外部调用时能实例化对象（这里不考虑反射的情况，对于反射可以直接暴力访问） 2、饿汉式单例模式，由于在类加载时就已经初始化对象，所以只会有一个实例。 3、饱汉式单例模式，在使用时才去实例化对象，这样就需要
java高级设计模式之单例模式
youjiangtengwan1的博客
11-03 3195
一、定义 保证一个类仅有一个实例，并提供一个访问它的全局访问点。 二、结构和说明  三、基本实现 四、认识单例模式    1、单例模式的功能         单例模式的功能是用来保证这个类的运行期间只会被创建一个类实例，并提供一个全局唯一访问这个类实例的访问点。     2、单例模式的范围        是一个ClassLoader及其子ClassLoader的范围 ...
Java设计模式——单例模式
m0_60500421的博客
08-16 1911
Java设计模式——单例模式
Java 设计模式——单例模式
代码星辰的博客
07-08 4264
本文介绍了单例模式的相关知识。
Java 中的单例模式
最新发布
2201_75437633的博客
03-31 1107
引言：在 Java 编程中，单例模式是一种常见的设计模式，它保证一个类只能创建一个实例，并提供一个全局访问点。单例模式在很多场景下都非常有用，比如线程池、日志系统、数据库连接池等。本文将详细介绍 Java 中单例模式的实现方式，并通过示例说明其在实际应用中的应用场景。
Java实现单例模式：详解与代码示例
总结来说，单例模式是软件设计中常用的一种模式，用于控制类的实例化过程，确保在整个应用程序中只有一个实例存在。通过饿汉式、懒汉式和双重检查锁定等实现方式，我们可以根据具体需求选择合适的方法来创建和管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值