浅析Java单例设计模式，自写demo，简单易懂

缺乏、安全感 2023-10-03 17:55 4阅读 0赞

## 单例模式特点： ##

1、构造器私有

2、在一个Java应用程序中，可保证只有一个实例对象

3、只提供一个供外界调用的getInstance()方法

## 单例模式优点： ##

1、减少某些对象的频繁创建，降低系统开销和内存占用

2、外部调用不使用new关键字，降低系统内存的使用频率

3、对于特殊的类，在系统中只能存在一个实例，否则系统无法正常运行，比如Controller

### 这里简单介绍两种实现方式 ###

#### 饿汉式（线程安全） ####

/**
     * @author: xuzhilei6656
     * @create: 2021-12-12 12:07
     * @description: 单例模式（饿汉式）
     **/
    public class Singleton {
        //创建实例
        private static Singleton instance = new Singleton();
    
        //私有构造器
        private Singleton(){
        }
    
        //获取实例的静态方法
        public static Singleton getInstance(){
            return instance;
        }
    
    }

实例对象在类被加载的时候就已经完成初始化，外界调用拿到的都是这个唯一的实例对象

#### 懒汉式 ####

/**
     * @author: xuzhilei6656
     * @create: 2021-12-12 12:22
     * @description: 单例模式（懒汉式）
     **/
    public class Singleton {
        //声明一个变量
        private static Singleton instance;
    
        //私有构造器
        private Singleton(){
        }
    
        //获取实例的静态方法
        public static Singleton getInstance(){
            //如果是首次调用，实例对象还没有被创建，就需要创建，否则都是返回已经创建过的那个对象
            if (instance == null){
                instance = new Singleton();
            }
            return instance;
        }
    
    }

对比饿汉式可见，实例对象在类被加载的时候并没有进行创建，在首次调用的时候才被创建，以后再被调用，返回的也是那个唯一的实例对象。

**在多线程情况下，这种写法存在线程安全问题**，比如：线程A在执行完if判断条件后进入阻塞状态，此时并没有进行对象创建，此时线程B来了，在执行完if条件后直接进行对象创建，等线程A恢复运行状态后也会进行对象创建，这个时候就不符合单例模式了，即出现了**线程不安全的问题**。

解决方案：**在获取实例的静态方法上加synchronized关键字，即加锁**

/**
     * @author: xuzhilei6656
     * @create: 2021-12-12 12:22
     * @description: 单例模式（懒汉式）
     **/
    public class Singleton {
        //声明一个变量
        private static Singleton instance;
    
        //私有构造器
        private Singleton(){
        }
    
        //获取实例的静态方法
        public static synchronized Singleton getInstance(){
            //如果是首次调用，实例对象还没有被创建，就需要创建，否则都是返回已经创建过的那个对象
            if (instance == null){
                instance = new Singleton();
            }
            return instance;
        }
    
    }

简单粗暴，可达到我们的目的，但是每次获取实例对象都要有加锁操作，影响系统性能。

改进后的方案：**双重检查**

/**
     * @author: xuzhilei6656
     * @create: 2021-12-12 12:22
     * @description: 单例模式（懒汉式）
     **/
    public class Singleton {
        //声明一个变量
        private static Singleton instance;
    
        //私有构造器
        private Singleton(){
        }
    
        //获取实例的静态方法
        public static synchronized Singleton getInstance(){
            //第一次检查
            if (instance == null){
                //获取锁
                synchronized (Singleton.class){
                    //第二次检查
                    if (instance==null){
                        //两次检查都确定没有已存在的实例对象，这才进行对象的创建操作
                        instance = new Singleton();
                    }
                }
                
            }
            return instance;
        }
    
    }

这样不必每次获取实例对象的时候都进行加锁操作，只有在第一次创建对象的时候才进行加锁操作，提高了系统性能。

但是，即使这样有可能会出现。因为 instance = new Singleton()这行代码在JVM中是两个操作，赋值和初始化实例，但JVM并不保证这两个操作的顺序，有可能JVM给新对象分配了空间，直接赋值给instance变量，然后才去做初始化实例操作。比如下面这种情况

1，A，B两个线程都进入第一个if条件

2，A线程先抢到锁进入到synchronized代码块，执行了instance = new Singleton()这行代码，然后释放锁，此时有可能JVM只给实例对象分配了空白的内存空间，并没有执行初始化操作

3，B线程抢到锁，进入到synchronized代码块，第二次判断的时候发现instance不是null，直接返回使用却发现得到的对象还没有被初始化，于是出现了问题。

再次改进：**使用volatile关键字修饰声明的成员变量instance**

/**
     * @author: xuzhilei6656
     * @create: 2021-12-12 12:22
     * @description: 单例模式（懒汉式）
     **/
    public class Singleton {
        //声明变量,被volatile修饰
        private volatile static Singleton instance;
    
        //私有构造器
        private Singleton(){
        }
    
        //获取实例的静态方法
        public static synchronized Singleton getInstance(){
            //第一次检查
            if (instance == null){
                //获取锁
                synchronized (Singleton.class){
                    //第二次检查
                    if (instance==null){
                        //两次检查都确定没有已存在的实例对象，这才进行对象的创建操作
                        instance = new Singleton();
                    }
                }
    
            }
            return instance;
        }
    
    }

volatile关键字作用：通过volatile修饰的变量，不会被线程本地缓存，所有线程对该对象的读写都会第一时间同步到主内存，从而保证多个线程间该对象的准确性。

这个写法已经比较完美了，既能保证安全的创建出唯一实例，又不会对系统性能有太大影响。

不过，还有更优的写法：**静态内部类实现（懒汉式）**

/**
     * @author: xuzhilei6656
     * @create: 2021-12-12 15:17
     * @description: 单例模式
     **/
    public class Singleton {
    
        //私有构造器
        private Singleton() {
        }
    
        //静态内部类声明实例
        private static class SingletonFactory{
            private static Singleton instance = new Singleton();
        }
    
        //获取实例的静态方法
        public static Singleton getInstance(){
            return SingletonFactory.instance;
        }
        
    }

使用内部类来维护单例的实现，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance()方法的时候，JVM能够保证创建出唯一的实例对象，并且这个实例对象是已经被初始化完成的，就解决了上面的线程安全问题

最后一种实现单例的写法也很完美，代码最简洁

**通过枚举（饿汉式）**

/**
     * @author: xuzhilei6656
     * @create: 2021-12-12 15:33
     * @description: 单例模式
     **/
    public enum Singleton {
    
        //代表一个Singleton实例
        INSTANCE;
    }

通过枚举来实现单实例代码更加简洁，而且JVM从根本上保证实例对象的唯一性，是更简洁、高效、安全的实现单例的方式

以上是个人学习时敲的demo，有不正确的地方，还请谅解，希望对朋友们有帮助，谢谢！