设计模型-五种单例模型

最新推荐文章于 2024-08-22 09:12:59 发布
最新推荐文章于 2024-08-22 09:12:59 发布
阅读量457 收藏
点赞数
分类专栏： Java基础总结
原文链接：https://www.cnblogs.com/qiu_jiaqi/p/Design-Patterns-Singleton.html
版权

一. 什么是单例模式

只需要某个类同时保留一个对象，不希望有更多对象，此时，我们则应考虑单例模式的设计。

单例模式的主要作用是保证在Java程序中，某个类只有一个实例存在。

单例模式有很多好处，它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间；

能够避免由于操作多个实例导致的逻辑错误。如果一个对象有可能贯穿整个应用程序，而且起到了全局统一管理控制的作用，那么单例模式也许是一个值得考虑的选择。

二. 单例模式的特点

1. 单例模式只能有一个实例。

2. 单例类必须创建自己的唯一实例。

3. 单例类必须向其他对象提供这一实例。

三. 单例模式VS静态类

在知道了什么是单例模式后，我想你一定会想到静态类，“既然只使用一个对象，为何不干脆使用静态类？”，这里我会将单例模式和静态类进行一个比较。

1. 单例可以继承和被继承，方法可以被override，而静态方法不可以。

2. 静态方法中产生的对象会在执行后被释放，进而被GC清理，不会一直存在于内存中。

3. 静态类会在第一次运行时初始化，单例模式可以有其他的选择，即可以延迟加载。

4. 基于2， 3条，由于单例对象往往存在于DAO层（例如sessionFactory），如果反复的初始化和释放，则会占用很多资源，而使用单例模式将其常驻于内存可以更加节约资源。

5. 静态方法有更高的访问效率。

6. 单例模式很容易被测试。

几个关于静态类的误解：

误解一：静态方法常驻内存而实例方法不是。

实际上，特殊编写的实例方法可以常驻内存，而静态方法需要不断初始化和释放。

误解二：静态方法在堆(heap)上，实例方法在栈(stack)上。

实际上，都是加载到特殊的不可写的代码内存区域中。

静态类和单例模式情景的选择：

情景一：不需要维持任何状态，仅仅用于全局访问，此时更适合使用静态类。

情景二：需要维持一些特定的状态，此时更适合使用单例模式。

以上转自：https://my.oschina.net/u/4261956/blog/3252045

单例模型的写法

实现单例方式有五种：饿汉式、懒汉式、双重校验锁(DCL)、静态内部类、枚举。

饿汉式

优点：在类加载的时候就完成实例化，避免了线程同步问题。

缺点：在类装载的时候就完成实例化，没有达到 Lazy Loading 的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

public class Singleton1 {
    private static final Singleton1 INSTANCE = new Singleton1();
    
    private Singleton1() {
        System.out.println("饿汉式，可用");
    }
    
    public static Singleton1 getInstance() {
        return INSTANCE;
    }
}

懒汉式

优点：达到了懒加载的效果。

缺点：线程不安全。

  1. 对于普通懒汉式，线程不安全。

    原因：在进入if (instance == null) 时，可能一个线程进入后就切换到了另一个线程，而此时并未创建实例对象，这个线程又再次进入了if代码块。

    public class Singleton2 {
    private static Singleton2 instance;

    private Singleton2() {
        System.out.println("懒汉式，线程不安全，多线程不可用");
    }

    public static Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}

  2. 对方法添加synchronized保证线程安全。

    synchronized保证了getInstance()线程安全，但对方法进行同步效率不高。

    public class Singleton3 {
    private static Singleton3 instance;

    private Singleton3() {
        System.out.println("懒汉式(synchronized方法)，效率太低");
    }

    public static synchronized Singleton3 getInstance() {
        if (instance == null) {
            instance = new Singleton3();
        }
        return instance;
    }
}

  3. 改进方案2，使用synchronized代码块。

    使用了synchronized代码块改进，但又出现了和方案1一样的线程安全问题。

    public class Singleton4 {
    private static Singleton4 instance;

    private Singleton4() {
        System.out.println("懒汉式(synchronized代码块)，线程不安全，多线程不可用");
    }

    public static Singleton4 getInstance() {
        if (instance == null) {
            synchronized (Singleton4.class) {
                // 此处若有线程阻塞，其它线程就仍可以进入到了前面if
                instance = new Singleton4();
            }
        }
        return instance;
    }
}

双重校验锁(DCL)

针对上一个改进，使用两个if (instance == null) 。

这里先别管实现的Serializable接口和readResolve()方法，这两个用于后面的序列化测试。

另外，此处的volatile声明是很重要的，volatile变量有两种特性。

一是保证了此变量对所有线程的可见性。“可见性”指的是当一条线程修改了这个变量的值，新值对于其它线程来说是可以立即知道的。

二是禁止指令重排序优化。但volatile变量的运行在并发编程下并非是安全的，因为不能保证原子性。详细请自己去看相关资料。

import java.io.Serializable;

public class Singleton5 implements Serializable {
    private static final long serialVersionUID = 1L;
    private static volatile Singleton5 instance;

    private Singleton5() {
        System.out.println("懒汉式优化(Double Check Lock)双重校验锁，推荐用");
    }

    public static Singleton5 getInstance() {
        if (instance == null) {
            // 未被初始化，但是无法确定这时其他线程是否已经对其初始化，因此添加对象锁进行互斥
            synchronized (Singleton5.class) {
                // 再一次进行检查，因为有可能在当前线程阻塞的时候，其他线程对instance进行初始化
                if (instance == null) {
                    // 此时还未被初始化的话，在这里初始化可以保证线程安全
                    instance = new Singleton5();
                }
            }
        }
        return instance;
    }

    // 如果该对象被用于序列化,该方法可以保证对象在序列化前后保持一致
    private Object readResolve() {
        return getInstance();
    }
}

静态内部类

静态内部类方式在类被加载时并不会立即实例化。

而是在需要实例化时，调用getInstance()方法，才会装载内部类，从而完成对象实例化。

import java.io.Serializable;

public class Singleton6 implements Serializable {
    private static final long serialVersionUID = 1L;

    private Singleton6() {
        System.out.println("饿汉式优化(静态内部类)，推荐用");
    }

    private static class SingletonInstance {
        private static final Singleton6 INSTANCE = new Singleton6();
    }

    public static Singleton6 getInstance() {
        return SingletonInstance.INSTANCE;
    }

    // 如果该对象被用于序列化,该方法可以保证对象在序列化前后保持一致
    private Object readResolve() {
        return getInstance();
    }
}

枚举

枚举方法不仅保证了线程安全问题，还提供了序列化机制。

public enum Singleton7 {
    INSTANCE;

    private Singleton7() {
        System.out.println("枚举，最好方法");
    }

    public static Singleton7 getInstance() {
        return INSTANCE;
    }
}

测试

线程安全测试

public class TestSafety {
    static Singleton1 s1_a;
    static Singleton1 s1_b;
    static Singleton2 s2_a;
    static Singleton2 s2_b;
    static Singleton3 s3_a;
    static Singleton3 s3_b;
    static Singleton4 s4_a;
    static Singleton4 s4_b;
    static Singleton5 s5_a;
    static Singleton5 s5_b;
    static Singleton6 s6_a;
    static Singleton6 s6_b;
    static Singleton7 s7_a;
    static Singleton7 s7_b;

    public static void getS1_A() {
        s1_a = Singleton1.getInstance();
    }

    public static void getS1_B() {
        s1_b = Singleton1.getInstance();
    }

    public static void getS2_A() {
        s2_a = Singleton2.getInstance();
    }

    public static void getS2_B() {
        s2_b = Singleton2.getInstance();
    }

    public static void getS3_A() {
        s3_a = Singleton3.getInstance();
    }

    public static void getS3_B() {
        s3_b = Singleton3.getInstance();
    }

    public static void getS4_A() {
        s4_a = Singleton4.getInstance();
    }

    public static void getS4_B() {
        s4_b = Singleton4.getInstance();
    }

    public static void getS5_A() {
        s5_a = Singleton5.getInstance();
    }

    public static void getS5_B() {
        s5_b = Singleton5.getInstance();
    }

    public static void getS6_A() {
        s6_a = Singleton6.getInstance();
    }

    public static void getS6_B() {
        s6_b = Singleton6.getInstance();
    }

    public static void getS7_A() {
        s7_a = Singleton7.getInstance();
    }

    public static void getS7_B() {
        s7_b = Singleton7.getInstance();
    }

    public static void main(String[] args) {
        Thread t1_a = new Thread(TestSafety::getS1_A);
        Thread t1_b = new Thread(TestSafety::getS1_B);
        t1_a.start();
        t1_b.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("s1_a == s1_b ? " + (s1_a == s1_b));
        System.out.println();

        Thread t2_a = new Thread(TestSafety::getS2_A);
        Thread t2_b = new Thread(TestSafety::getS2_B);
        t2_a.start();
        t2_b.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("s2_a == s2_b ? " + (s2_a == s2_b));
        System.out.println();

        Thread t3_a = new Thread(TestSafety::getS3_A);
        Thread t3_b = new Thread(TestSafety::getS3_B);
        t3_a.start();
        t3_b.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("s3_a == s3_b ? " + (s3_a == s3_b));
        System.out.println();

        Thread t4_a = new Thread(TestSafety::getS4_A);
        Thread t4_b = new Thread(TestSafety::getS4_B);
        t4_a.start();
        t4_b.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("s4_a == s4_b ? " + (s4_a == s4_b));
        System.out.println();

        Thread t5_a = new Thread(TestSafety::getS5_A);
        Thread t5_b = new Thread(TestSafety::getS5_B);
        t5_a.start();
        t5_b.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("s5_a == s5_b ? " + (s5_a == s5_b));
        System.out.println();

        Thread t6_a = new Thread(TestSafety::getS6_A);
        Thread t6_b = new Thread(TestSafety::getS6_B);
        t6_a.start();
        t6_b.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("s6_a == s6_b ? " + (s6_a == s6_b));
        System.out.println();

        Thread t7_a = new Thread(TestSafety::getS7_A);
        Thread t7_b = new Thread(TestSafety::getS7_B);
        t7_a.start();
        t7_b.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("s7_a == s7_b ? " + (s7_a == s7_b));
        System.out.println();
    }
}

输出结果：

饿汉式，可用
s1_a == s1_b ? true

懒汉式，线程不安全，多线程不可用
懒汉式，线程不安全，多线程不可用
s2_a == s2_b ? false

懒汉式(synchronized方法)，效率太低
s3_a == s3_b ? true

懒汉式(synchronized代码块)，线程不安全，多线程不可用
懒汉式(synchronized代码块)，线程不安全，多线程不可用
s4_a == s4_b ? false

懒汉式优化(Double Check Lock)双重校验锁，推荐用
s5_a == s5_b ? true

饿汉式优化(静态内部类)，推荐用
s6_a == s6_b ? true

枚举，最好方法
s7_a == s7_b ? true

序列化测试

只对双重校验锁、静态内部类、枚举测试。

默认只有枚举能保证序列化后对象仍相等，其它需要加readResolve()方法才能。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.nio.file.Path;
import java.nio.file.Paths;

public class TestSerializable {
    // 测试序列化后的对象是否相等
    public static void main(String[] args) {
        Singleton5 s5_a = Singleton5.getInstance();
        Singleton5 s5_b = Singleton5.getInstance();
        System.out.println("序列化前：s5_a == s5_b ? " + (s5_a == s5_b));
        Path file5 = Paths.get("object5.txt");
        try (ObjectOutputStream out = new ObjectOutputStream(
                new FileOutputStream(file5.toFile()))) {
            out.writeObject(s5_a);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try (ObjectInputStream in = new ObjectInputStream(
                new FileInputStream(file5.toFile()))) {
            s5_b = (Singleton5) in.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("序列化后：s5_a == s5_b ? " + (s5_a == s5_b));
        System.out.println();

        Singleton6 s6_a = Singleton6.getInstance();
        Singleton6 s6_b = Singleton6.getInstance();
        System.out.println("序列化前：s6_a == s6_b ? " + (s6_a == s6_b));
        Path file6 = Paths.get("object6.txt");
        try (ObjectOutputStream out = new ObjectOutputStream(
                new FileOutputStream(file6.toFile()))) {
            out.writeObject(s6_a);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try (ObjectInputStream in = new ObjectInputStream(
                new FileInputStream(file6.toFile()))) {
            s6_b = (Singleton6) in.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("序列化后：s6_a == s6_b ? " + (s6_a == s6_b));
        System.out.println();

        Singleton7 s7_a = Singleton7.getInstance();
        Singleton7 s7_b = Singleton7.getInstance();
        System.out.println("序列化前：s7_a == s7_b ? " + (s7_a == s7_b));
        Path file7 = Paths.get("object7.txt");
        try (ObjectOutputStream out = new ObjectOutputStream(
                new FileOutputStream(file7.toFile()))) {
            out.writeObject(s7_a);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try (ObjectInputStream in = new ObjectInputStream(
                new FileInputStream(file7.toFile()))) {
            s7_b = (Singleton7) in.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("序列化后：s7_a == s7_b ? " + (s7_a == s7_b));
        System.out.println();
    }
}

先把readResolve()方法注释掉；输出结果为：

懒汉式优化(Double Check Lock)双重校验锁，推荐用
序列化前：s5_a == s5_b ? true
序列化后：s5_a == s5_b ? false

饿汉式优化(静态内部类)，推荐用
序列化前：s6_a == s6_b ? true
序列化后：s6_a == s6_b ? false

枚举，最好方法
序列化前：s7_a == s7_b ? true
序列化后：s7_a == s7_b ? true

加上readResolve()方法，枚举不需要，枚举甚至连Serializable接口都不需实现；输出结果如下：

懒汉式优化(Double Check Lock)双重校验锁，推荐用
序列化前：s5_a == s5_b ? true
序列化后：s5_a == s5_b ? true

饿汉式优化(静态内部类)，推荐用
序列化前：s6_a == s6_b ? true
序列化后：s6_a == s6_b ? true

枚举，最好方法
序列化前：s7_a == s7_b ? true
序列化后：s7_a == s7_b ? true

使用场景

  • 文件管理系统
  • 日志记录类
  • 与数据库的连接

应用实例

java.lang.Runtime#getRuntime()

以上转自：https://www.cnblogs.com/qiu_jiaqi/p/Design-Patterns-Singleton.html

冬天里的被窝窝
关注
专栏目录
设计模式学习笔记--单例(Singleton)和多例(Multiton)
Java之旅
03-30 2510
单例(Singleton)模式一个最重要的特点是类的构造方法是私有的，从而避免了外部利用构造方法直接创建多个实例，同时它是自实例化的；多例模式（Multiton Pattern），实际上就是单例模式的自然推广。
【Java】设计模型-五种单例模型
weixin_34342992的博客
09-04 119
一. 什么是单例模式 只需要某个类同时保留一个对象，不希望有更多对象，此时，我们则应考虑单例模式的设计。 单例模式的主要作用是保证在Java程序中，某个类只有一个实例存在。 单例模式有很多好处，它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间； 能够避免由于操作多个实例导致的逻辑错误。如果一个对象有可能贯穿整个应用程序，而且起到了全局统一管理控制的作用，...
设计模式-单例模式（Singleton Pattern）
最新发布
weixin_60653563的博客
08-22 1225
单例模式。饿汉式单例；懒汉式；枚举式单例；容器式单例；ThreadLocal式单例。
设计模式-单例模型
weixin_45351103的博客
02-07 402
设计模式-单例模型1 设计模式2 什么是单例3 懒汉模式3.1 懒汉模式的线程安全问题3.2 线程安全解决方案方案一：在getInstance()方法前加synchronized锁**方案二：可重复锁4 饿汉模式5 用单例模型改造jdbc 1 设计模式 jdbc–> 封装(static)–>properties(配置文件)–>数据源(dbcp)–>单例 2 什么是单例 创建型模式：创建对象 单例模型的核心：内存中只有唯一的一个对象 在普通类中，是容易产生多个对象的。比如： pub
设计模型之单例设计
qq_58259539的博客
12-03 408
注意：1.单例类只能有一个类。2单例类必须创建自己的唯一id.单例设计模式分为两种：饿汉式：类加载就会导致该单实例对象被创建。懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会被创建。饿汉式实现方式一： 饿汉式实现方式二：静态代码块 懒汉式实现方法一： 但是这种方法在多线程里是不安全的，当有两个线程时，一个线程执行到判断语句判断instance是否为null时，处于等待状态，而另一个线程获得CPU的执行权，也会进行判断里面，这时会创建两个Singleton对象。懒汉
设计模型之创建型模式之单例模式（Singleton）
itlwc
06-26 1229
定义：保证在一个JVM中，一个对象只有一个实例，并提供一个访问它的全局访问点。应用：某些对象创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。优点：省去new操作符，可以降低系统内存的使用频率，减轻GC压力。比如：有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。普通单例模式代码：public
Swift-单例Swift-单例Swift-单例Swift-单例Swift-单例
05-28
单例模式是软件设计模式之一，它保证了类只有一个实例，并提供一个全局访问点。在Swift中，单例模式的实现方式有多种，下面我们将深入探讨这一主题。 首先，单例模式的主要用途在于控制共享资源，确保在整个应用...
java代码-double check单例模式
07-16
在Java编程中，单例模式是一种常用的创建型设计模式，它的目标是确保一个类只有一个实例，并提供一个全局访问点。这种模式在系统中需要频繁创建和销毁对象，且对象之间存在大量的交互时非常有用，因为它可以减少内存...
Python的设计模型-----工厂模式和单例模式
偷得浮生半日闲
10-16 658
设计模式是面向对象语言特有的内容，使我们在面临某一类问题时固定的做法，设计模式有很多种，比较流行的是：GOF（Goup Of Four）23种设计模式。我们没有必要全学，学习几个常用的的即可 我们最常用的模式：工厂模式和单例模式（只要在复杂的场景在会使用） 工厂模式 工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。 【例子】 # 工厂模式 ''' 一般情况下我们要创建一个工厂类（创造我们想创造...
Java学习笔记之--------单例模式（一）
wangruoao的博客
09-19 298
单例模式的核心作用 保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。 单例模式的应用场景 Windows的Task Manager（任务管理器）。 Windows的Recycle Bin（回收站）。在整个系统运行过程中，回收站一直维护着仅有的一个实例。 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都new一个对象去读取。 网站的计数器，一般也...
C#-设计模式-单例模式
Asincereman的专栏
01-14 1083
1、提供了对唯一实例的受控访问。2、由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。3、允许可变数目的实例。
按需释放单例模型的改进版例子
12-05
本资源是《C++中的单例模式及按需释放模型》系列博文的改进例子，文章地址为http://blog.csdn.net/gogogo/article/details/7041907，其中提到了如何在C++正确使用单例模式，并讲解了使用辅助类实现可以按需释放的单例模型，同时给出了多线程的模型，其改进主要是使用了操作符重载，使用起来更加方便简洁。
设计模式之单例模式
ding_GC的博客
05-28 399
单例模式定义确保某一个类仅有一个实例对象，而且自行实例化并向整个系统提供这个实例。单例模式使用场景确保某个类只有一个对象的场景，避免产生多个对象浪费资源，或者某种类型对象只应该有且只有一个。单例模式要素1，构造函数不对外开放，一般为private;2，通过一个静态方法或者枚举返回单例类对象；3，确保单例类的对象有且只有一个，尤其是在多线程环境下；4，确保单例类对象在反序列化过程中不会重新构建对象；...
设计模式-单例模式
~O~
06-24 686
原理：单例对象的类必须保证只有一个实例存在。优点：1.单例模式只存在一个实例 2.节约资源，需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能 3.避免对共享资源的多重占用缺点：1.扩展困难 2.职责过重，一定程度上违反了“单一原则” 3.不适用于需要变化的对象注意事项：1.使用时不能用反射模式创建单例，否则会实例化一个新的对象 2.使用懒单例模式时注意线程安全问题 3.饿单例模式和懒单...
单例设计模型
qq_40476342的博客
03-16 345
设计模式是在大量的实践中总结和理论化之后的优选的代码结构、编程风格、以及解决问题的思考模式。单例设计模式主要分为：饿汉式与懒汉式
设计模式：单例模式-懒汉模型和饿汉模型
ChaseRaod的博客
07-31 749
什么是单例模式？保证一个类只有一个实例，并提供一个访问它的全局访问点。首先，需要保证一个类只有一个实例；在类中，要构造一个实例，就必须调用类的构造函数，如此，为了防止在外部调用类的构造函数而构造实例，需要将构造函数的访问权限标记为protected或private；最后，需要提供要给全局访问点，就需要在类中定义一个static函数，返回在类内部唯一构造的实例。要求：（1）单例类保证全局只有一个自行创
单例模型详解
weixin_30852451的博客
09-30 668
一、单例的由来 在我们的程序中，如果需要多个线程操作同一对象，需要保证对象的唯一性。如何保证唯一性呢？ 二、解决的问题 对象实例化过程中，只实例化一次 三、解决的思路 有一个实例化过程（仅仅只有一次），提供返回实例的方法 四、单例模式的分类 我们从几个方面考虑单例模型的性能：安全性、 1、饿汉式 public class HungrySing...
设计模式解析：单例模式与工厂模式
"这篇文档详细介绍了23种设计模式，包括单例模式、工厂模式、抽象工厂模式、建造者模式、代理模式和原型模式等。这些模式是软件设计中的重要概念，有助于提高代码的可复用性和可维护性。文档提供了各模式的定义、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值