单例模式的案例

最新推荐文章于 2023-07-25 20:54:09 发布

一个喜欢打篮球的程序猿

最新推荐文章于 2023-07-25 20:54:09 发布

阅读量268

点赞数

文章标签：单例模式 java 开发语言

本文链接：https://blog.csdn.net/czongzong/article/details/127992517

版权

1、饿汉式

饿汉式单例模式（直接实例化饿汉式）

// 饿汉式单例模式（直接实例化饿汉式）：直接创建一个实例
    // 1. 构造器私有化
    // 2. 创建实例，并且是静态的
    // 3. 向外暴露
    // 4. final常量化固定单例
public class Singleton1 {
    public static final Singleton1 INSTANCE = new Singleton1();

    private Singleton1(){

    }
}

饿汉式：枚举

// 饿汉式：枚举
public enum Singleton2 {
    INSTANCE
}

静态代码块饿汉式

// 饿汉式：静态代码块饿汉式
public class Singleton3 {
    public static final Singleton3 INSTANCE;

    static {
        // 用处：当要在外进行加载文件传入到 new Singleton3();
        INSTANCE = new Singleton3();
    }

    private Singleton3(){

    }
}

2、懒汉式

懒汉式：存在线程安全问题，在需要的时候才创建实例

// 懒汉式：存在线程安全问题，在需要的时候才创建实例
    // 1. 构造器私有化
    // 2. 创建私有化静态变量来保存唯一的实例
    // 3. 创建静态方法，获取一个实例
public class Singleton4 {
    private static Singleton4 instance;

    private Singleton4(){

    }

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

        return instance;
    }
}

懒汉式：线程安全(双端检锁机制)

// 懒汉式：线程安全
public class Singleton5 {
    private static Singleton5 instance;

    private Singleton5(){

    }

    public static Singleton5 getInstance(){
        if (instance == null){
            // 加锁：防止多线程下创建多个实例
            synchronized (Singleton5.class){
                if (instance == null){
                    instance = new Singleton5();
                }
            }
        }

        return instance;
    }
}

懒汉式：创建静态内部类

// 懒汉式：创建静态内部类
    // 只有在内部类创建并初始化的时候才会创建实例
    // 内部类不会随着外部内的创建和初始化而进行加载，是单独进行创建和初始化的
    // 因为是在内部类进行加载和初始化的时候进行创建的，所有是线程安全的

public class Singleton6 {
    private Singleton6(){

    }

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

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

解决线程安全问题（双端检锁机制+volatile）

// 解决多线程的情况下单例模式
public class Singleton7 {

    private static volatile Singleton7 instance = null;

    private Singleton7(){
        System.out.println(Thread.currentThread().getName() + "\t" + "构造方法被执行");
    }

    // 多线程的情况下使用DCL模式（Double Check Lock）双端检锁机制
    // 但是这个方法不能够完全实现单例模式，因为存在指令重排，可能存在：在没有进行完成new对象并且赋值的情况直接返回了空地址，得到的是空对象，所以使用volatile来禁止指令重排
    public static Singleton7 getInstance(){
        if (instance == null){
            synchronized (Singleton7.class){
                if (instance == null){
                    instance = new Singleton7();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            new Thread(()->{
                Singleton7.getInstance();
            },String.valueOf(i)).start();
        }
    }
}