Android中常见的单例模式及其特点

单例模式在日常开发当中是比较常用的，本文主要介绍常见的单例模式及其特点。

1.饿汉式（不推荐）

    饿汉式：顾名思义就是很饿，类加载的时候我就初始化，不管你用不用的到。

/**
 * Created by laoyang on 2022/09/07.
 */
public class SingleInstance {

    private static final SingleInstance instance = new SingleInstance();

    private SingleInstance() {

    }

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

通过上面的代码可以看到实例instance使用了static修饰符，我们知道static修饰的变量或者是常量是在类加载的时候就进行初始化了，并且只加载一次。所以我们知道了为什么这种单例模式叫做饿汉式了。

另外饿汉式无需加锁就可以保证线程安全，上代码

public class SingleInstanceTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SingleInstance singleInstance1=SingleInstance.getInstance();
        SingleInstance SingleInstance2=SingleInstance.getInstance();

        System.out.println(singleInstance1);
        System.out.println(SingleInstance2);
    }
}

打印结果：

 对象的引用完全相同，说明就是一个对象，验证了饿汉式是线程安全的。

饿汉式的优缺点

优点：

1、无需加锁就能保证线程的安全，因为JVM在类加载的过程保证了不会初始化多个static对象。

2、类加载时就初始化了，这样程序执行效率高。

缺点：

1.正是因为类加载时就已经帮我们初始化好了不管你是否使用，所以会造成内存的浪费。如果一个程序有大量的饿汉式单例模式存在，那么在类加载时，会同时创建大量单例，会浪费硬件资源。

反射代码如下

package com.example.demo;

import java.lang.reflect.Constructor;

/**
 * Created by laoyang on 2022/09/07.
 */
public class SingleInstance {

    private static final SingleInstance instance = new SingleInstance();

    private SingleInstance() {

    }

    public static SingleInstance getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        try {
            Class<?> clazz = SingleInstance.class;
            Constructor c = clazz.getDeclaredConstructor(null);
            c.setAccessible(true);
            Object instance1 = c.newInstance();
            Object instance2 = c.newInstance();
            System.out.println(instance1);
            System.out.println(instance2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 打印结果：

 对象的引用不同了，通过映射可以破坏饿汉式的单例

2.懒汉式（不推荐）

   懒汉式:跟饿汉式完全两种性格，你不找我我就不干。

/**
 * Created by laoyang on 2022/09/07.
 */
public class SingleInstance {

    private static SingleInstance instance;

    private  SingleInstance() {}

    public static synchronized SingleInstance getInstance() {
        if (instance == null) {
            instance = new SingleInstance();
        }
        return instance;
    }
}

 上面的代码可以看出，外部需要调用getInstance这个方法才会初始化。

懒汉式优缺点：

优点：
1，使用时直接调用getInstance才进行初始化，防止资源浪费。

缺点：

1.效率低，每个线程想获得该实例都必须调用getInstance进行初始化都要同步效率太低。

3 双重检锁(推荐)
   

双重检锁单例模式其实是对上面懒汉式的一种优化

/**
 * Created by laoyang on 2022/09/07.
 */
public class SingleInstance {
    private volatile static SingleInstance instance;

    private SingleInstance() {
    }

    public static SingleInstance getInstance() {
        if (instance == null) {
            synchronized (SingleInstance.class) {
                if (instance == null) {
                    instance = new SingleInstance();
                }
            }
        }
        return instance;
    }
}

为什么要进行两次判空？

第一次判空就是为了效率，因为当instance不为空就不需要走到synchronized同步锁直接返回instance。

第二次判空，走到synchronized同步锁，当一个线程拿到这个锁时其他线程就要等待，直到被释放下一个线程才能拿到这个锁，第二次判空如果已经初始化了直接return,否则在进行初始化。这样才真正意义上做到了单例。

volatile修饰符为了让instance实例在发生变化后立即写入主存，方便其他线程读取，否则有可能造成空指针，因为new的过程不是一瞬间的，所以有可能在操作过程中，另一个线程读到instance还是空的。

4 静态内部类实现单例模式(非常推荐)

/**
 * Created by laoyang on 2022/09/07.
 */
public class SingleInstance {
    private static class SingleInnerClass{
        private static final SingleInstance instance = new SingleInstance();
    }

    public static SingleInstance getInstance(){
        return SingleInnerClass.instance;
    }
}

SingleInnerClass是一个静态内部类，当外部类 SingleInstance被加载的时候，并不会创建 SingleInnerClass实例对象。只有当调用 getInstance() 方法时，SingleInnerClass才会被加载(延迟加载)，这个时候才会创建 instance。静态属性保证了全局唯一，静态变量初始化保证了线程安全，所以这里的方法没有加synchronized关键字（JVM保证了一个类的 初始化在多线程下被同步加锁）