单例模式设计

合集 - JAVA(41)

1.Java_第一季_JAVASE_自增、单例模式、类与实例初始化过程、方法参数传递机制、递归和迭代、成员变量与局部变量2021-02-232.Java_第一季_SSM_Spring Bean的作用域、Spring事务的传播行为、Spring MVC的执行流程、2021-02-243.Java_第一季_java高级_Redis持久化、MySql何时建立索引2021-02-244.java_JUC、volatile2021-02-255.java_CAS2021-02-266.java_阻塞队列（FIFO先进先出）2021-03-107.JUC下countDownLatch、CyclicBarrier、Semaphore以及枚举的常见使用方法2021-03-058.java_锁2021-03-049.java_集合不安全2021-02-2610.Spring循环依赖2021-04-2011.AbstractQueuedSynchronizer---AQS2021-04-1912.LockSuport2021-04-1513.java_线程池7大参数_底层运行原理2021-03-1114.java_线程池三个常用方式2021-03-1115.Java_Callable<V>的基本使用2021-03-1016.java_锁_synchronized与Lock的区别2021-03-1017.java_强、软、弱、虚四大引用2021-03-1818.java_OOM2021-03-2519.JAVA-interview2021-06-0920.java_NIO2021-05-2021.java_JVM之GC2021-03-2522.java_JVM2021-03-23

23.单例模式设计2021-12-21

24.netty服务端、客户端简单搭建2022-01-1125.java使用webSocket与前端通讯2022-01-1126.java串口通讯2021-12-0327.用Java读取文件文字并语音播报2022-01-0728.Proguard-混淆2021-11-1729.Spring Security2021-12-0130.MQ2021-10-2631.spring相关面试题2021-06-2232.执行jar包2021-06-1133.Spring2021-06-0234.SpringBoot数据访问2021-05-2735.Java Stream（流）基本使用2023-12-2836.java集合工具类 Collections基本使用2023-12-2837.LocalDateTime、LocalDate、Date、String相互转化2023-12-2738.java8新特性2022-07-0939.java设计模式2021-12-2740.java springboot使用定时器2021-09-1941.MQ根据正常队列、死信队列来实现延迟队列的场景2024-08-28

收起

1、饿汉式

/**
 * 饿汉式：直接创建对象，不管你是否需要，都会创建这个对象；
 *
 * 1、构造器私有化
 * 2、自动创建，并且用静态保存
 * 3、向外提供这个实例
 * 4、强调这是一个单利模式，可以用final修饰
 */
public class Singleton1 {
    private Singleton1(){
    }
    public static final Singleton1 INSTANCE = new Singleton1();
}

2、枚举

/**
 * 枚举类型：表示该类型的对象是有限的几个，
 * 我们定义成一个，就成了单利模式
 */
public enum Singleton2 {
    INSTANCE
}

 

3、适用于初始化比较复杂的实例

/**
 * 适用于初始化比较复杂的实例；
 */
public class Singleton3 {
    public static final Singleton3 INSTANCE;
    private Singleton3(){
    }
    static {
        //此处初始化其他数据；
        INSTANCE = new Singleton3();
    }
}

 

4、懒汉式

/**
 * 懒汉式：延迟创建这个实例对象；
 *
 * 1、构造器私有化
 * 2、用一个静态变量保存这个唯一的实例；
 * 3、提供一个静态方法，获取这个实例；
 */
public class Singleton4 {
    private static Singleton4 instance;
    private Singleton4(){
    }
    public static Singleton4 getInstance(){
        if (instance == null){
            //Thread.sleep(100);此处睡眠，若两个线程同时进入，会创建两个对象
            instance = new Singleton4();
        }
        return instance;
    }
}

/**
 * 懒汉式：延迟创建这个实例对象；
 *
 * 1、构造器私有化
 * 2、用一个静态变量保存这个唯一的实例；
 * 3、提供一个静态方法，获取这个实例；
 */
public class Singleton5 {
    private static Singleton5 instance;
    private Singleton5(){
    }
    public static Singleton5 getInstance(){
        synchronized (Singleton5.class){
            if (instance == null){
                try {
                    //此处睡眠，若两个线程同时进入，会创建两个对象
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                instance = new Singleton5();
            }
        }
        return instance;
    }
}

 

5、内部类的方式

//在内部类加载的时候才会创建对象INSTANCE
//静态内部类不会自动随着外部类的加载和初始化而初始化，他是单独去加载和初始化的；
public class Singleton6 {
    private Singleton6(){
    }
    private static class Inner{//内部类
        private static final Singleton6 INSTANCE = new Singleton6();
    }
    public static Singleton6 getInstance(){
        return Inner.INSTANCE;
    }
}

 

6、双端检索机制（DCL）

public class SingletonDemo2 {
    public static volatile SingletonDemo2 instance = null;
    private SingletonDemo2(){
        System.out.println("SingletonDemo2");
    }
    //DCL（双端检索机制）
    public static SingletonDemo2 getInstance(){//由于指令重排机制，不一定100%线程安全
        if (instance == null){
            synchronized (SingletonDemo2.class){
                if (instance == null){
                    instance = new SingletonDemo2();
                }
            }
        }
        return instance;
    }

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