java 单例模式(5种实现方式)

单例模式(5种实现方式)

    • 单例模式简介
    • 五种实现方式
      • 1.懒汉式
        • 线程不安全:
        • 线程安全:
      • 2.饿汉式
      • 3.双检锁/双重校验锁(懒汉式的优化)
      • 4.静态内部类
      • 5.枚举
      • 注意:
    • 扩展

单例模式简介

单例模式(Singleton Pattern)是java中最简单的设计模式之一,它是一个创建型模式。
单例模式确保某个类在任何情况下绝对只有一个实例,并提供了一个全局访问点来访问这个实例。

确保类在内存中只存在一个实例对象。


五种实现方式

1.懒汉式

特点:单例对象被使用的时候才初始化,避免了内存浪费

线程不安全:

 
public class SingleObject {
    
    private static SingleObject instance;

    //让构造函数为 private,这样该类就不会被实例化
    private SingleObject(){}

    //获取唯一可用的对象
    public static SingleObject getInstance(){
        if(instance==null){
            instance=new SingleObject(); //调用时才实例化对象
        }
        return instance;
    }
}

这种方法实现了懒加载,但是却是线程不安全的,只能在单线程中使用,当有多个线程同时进入getInstance方法中的if判断中,若判断为null,就会创建多个实例对象。

线程安全:

为了解决线程不安全的情况,给getInstance方法加上关键字synchronized

public class SingleObject {
    
    private static SingleObject instance;

    //让构造函数为 private,这样该类就不会被实例化
    private SingleObject(){}

    //获取唯一可用的对象
    public synchronized static SingleObject getInstance(){
        if(instance==null){
            instance=new SingleObject(); //调用时才实例化对象
        }
        return instance;
    }
}

这样写虽然解决了线程安全,但是当有多个线程想要调用的时候,每个线程都要等上一个线程完成后再执行,大大降低了效率。

2.饿汉式

特点:没有实现懒加载,在类加载的时候初始化,即在运行之前只是将打包的代码加载到内存的时候就初始化,会造成内存浪费,但是它是线程安全的,并且执行效率高。

public class SingleObject {
    //创建 SingleObject 的一个对象
    private static SingleObject instance=new SingleObject();

    //让构造函数为 private,这样该类就不会被实例化
    private SingleObject(){}

    //获取唯一可用的对象
    public static SingleObject getInstance(){
        return instance;
    }
}

3.双检锁/双重校验锁(懒汉式的优化)

特点:在对象声明时添加关键字volatile,防止指令重排,如果不用volatile关键字,就会和线程不安全的情形一样,在if判断处有并发。
上面懒汉式的代码的执行效率低,在同步前判断一下是否实现了实例化,若是没有实例化就用同步方法new一个,否则就直接返回。

public class SingleObject {
    //使用volatile关键字防止指令重排
    private volatile static SingleObject instance;

    //让构造函数为 private,这样该类就不会被实例化
    private SingleObject(){}

    //获取唯一可用的对象
    public static SingleObject getInstance(){
        if(instance==null){
            synchronized (SingleObject.class){
                if(instance==null){
                    instance=new SingleObject();
                }
            }
        }
        return instance;
    }
}

使用两重if的原因是若是多个线程同时进入了第一层if判断,第一个线程进入锁中一定是没有问题的,但是其他的线程再进入锁中不进行判断就会再次新建一个对象。

4.静态内部类

特点:该方法使用静态内部类创建对象,在调用时加载内部类,然后返回对象,使用JVM保证了装载的线程安全,并且能够保证懒加载。

public class SingleObject {
    //让构造函数为 private,这样该类就不会被实例化
    private SingleObject(){}

    //内部类 默认是不加载的
    private static final class SingleHodle{
        private static final SingleObject INSTANCE=new SingleObject();
    }

    //获取唯一可用的对象
    public static SingleObject getInstance(){
        //返回之前一定会先加载内部类
        return SingleHodle.INSTANCE;
    }
}

静态内部类在外部类加载的时候不会实例化,在调用getInstance方法的时候,返回对象结构之间会加载内部类,从而实现了延迟加载。

5.枚举

特点:枚举就是饿汉式的单例模式在类加载时就初始化了。目前这种实现方式很少用,但是是最佳的单例模式的实现方式,它更简洁,而且支持序列化机制,绝对防止多次实例化。

public enum SingleObject {
    INSTANCE; //属性
    public void show(){
        System.out.println("this is method");
    }
}

注意:

前四种方式实现的单例模式都是可以通过反射和序列化破坏的。

扩展

解决反射方式破坏单例模式的问题:java 反射破坏单例模式以及解决方式
解决序列化方式破坏单例模式的问题:java 序列化破坏单例模式以及解决方式

你可能感兴趣的:(java,单例模式,开发语言)