Java设计模式之单例模式

白开水不加糖xy

已于 2022-12-28 15:03:06 修改

阅读量215

点赞数

分类专栏：笔记文章标签：设计模式

于 2020-06-25 22:51:04 首次发布

本文链接：https://blog.csdn.net/xy199931/article/details/106958295

版权

笔记专栏收录该内容

2 篇文章 0 订阅

订阅专栏

单例模式

单例模式定义
单例模式结构和实现
饿汉式单例
懒汉式单例
单例模式优缺点
适用环境

单例模式定义

单例模式定义就是确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。属于设计模式的创建型模式。
单例模式有3个要点：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例

单例模式结构和实现

单例模式结构

只包含一个类，即单例类。
对于Singleton,在类内创建唯一实例，通过静态方法GetInstance()让客户端可以使用它唯一实例；且为了防止被外部对单例类实例化，将单例类的构造函数访问权限设为private;在单例类内定义一个Singleton类型的静态对象供外部共享访问的唯一实例。

在这里插入图片描述

静态变量与非静态变量

被static关键字修饰的变量，叫类变量或静态变量；没有static修饰的是成员变量。

类的静态变量

在内存中只有一个，java虚拟机在类加载过程中为静态变量分配内存。
静态变量位于方法区，被类的所有实例所共享。
静态变量可通过类名来访问，其生命周期取决于实例的生命周期。

实例变量

取决于类的实例。每创建一个实例，java虚拟机会为实例变量分配一次内存。
实例变量位于堆中；其生命周期取决于实例的生命周期。

单例模式的实现

public class Singleton1 {
    private static Singleton1 instance=null;//静态私有成员变量

    //私有构造函数
    private Singleton1(){}

    //静态公有工厂方法，返回唯一实例
    public static Singleton1 getInstance(){
        if(instance==null)
            instance=new Singleton1();
        return instance;
    }
}

测试代码：

public class Client {
    public static void main(String[] args) {
        Singleton1 s1=Singleton1.getInstance();
        Singleton1 s2=Singleton1.getInstance();
        if(s1==s2){
            System.out.println("两个对象是相同实例");
        }else{
            System.out.println("两个对象是不同实例");
        }
    }
}

编译运行结果如下：

两个对象是相同实例

由上可看出两次调用getInstance()所获取的对象是同一实例对象，并无法再外部对Singleton实例化。
在单例模式的实现过程中需注意：

构造函数的可见性为private。
提供一个类型为自身的静态私有成员变量。
提供一个公有静态工厂方法

饿汉式单例

类被加载时，静态变量会被初始化，类的私有构造函数会被调用，单例类的唯一实例被创建。

饿汉式：线程安全，调用效率高。示例：

public class Singleton {
    //饿汉式
    private static Singleton instance=new Singleton();
    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}

特点：

无需考虑多个线程同时访问的问题，可确保实例的唯一性。
从调用速度和响应时间来看，由于单例对象一开始就得以创建，因此优于懒汉式单例。
无论系统运行时是否需要该单例对象，由于在类加载时该对象就创建，资源利用率不及懒汉式单例。
系统加载时创建饿汉式单例对象，使得加载时间会较长。

懒汉式单例

懒汉式单例在第一次被引用时实例化，类加载时不会被实例化。

懒汉式：线程不安全。示例：

public class LazySingleton {
    private static LazySingleton instance=null;
    
    private LazySingleton(){}
    
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

运行时加载对象，加载类较快，获取对象慢；线程不安全，可加synchronized关键字，但效率低。

懒汉式：双重校验锁。示例：

public class LazySingleton {
    private static volatile LazySingleton instance=null;

    private LazySingleton(){}

    public static LazySingleton getInstance() {
        //第一重判断
        if (instance == null) {
            //线程锁定，以处理多个线程同时访问的情况，线程安全
            synchronized (LazySingleton.class){
                //第二重判断
                if(instance==null){
                    instance=new LazySingleton();
                }
            }
        }
        return instance;
    }
}

第一个instance == null，提高效率：变量使用volatile关键字可以保证可见性。
第二个instance == null，为了保证单例：返回是同一个对象。

instance=new LazySingleton();
new对象分解三条指令：
1.分配内存空间
2.初始化对象
3.赋值给变量
假设不加volatile，但能保证变量保证可见性（不保证重排序）：若线程A以1-3-2，且执行到3时，另外的线程执行到第一个判断时进不去之后的代码，直接返回，会发生错误

volatile作用：