设计模式-创建型-单例模式

作者：wuzhuoyu

前言

单例模式介绍

在23种设计模式之中它是最简单的，应用范围最广的一种，保证一个类仅有一个实例，并提供一个访问它的全局访问点

##简介
定义

单例模式（ Singleton）隶属于创建型，原理主要是一个类有且仅有一个实例，内部提供给外部该实例的访问方式。

特点

有且仅有一个实例，并且构造函数私有化，仅向外部提供获取实例的方式，一般为getInstance

概要

全局一个对象，对象构造私有化

理解实现

现实模型
大家都知道我有一个卖果子的老乡，我的果子都是在他这儿买的，老乡现在生意是越做越大了，而我还是一如既往的贫困潦倒，现在的老乡已经是我们这个社区里唯一一个卖果子的男人了，所有的居民都买他的果子，我也是其中一员，买完回家吃了写水文。

分析模型
主线：全社区居民都在老乡这买果子，我买了吃完写水文。
模型1: 社区居民 -> 消费者
模型2: 老乡 -> 单例

社区居民（消费者）

public class Resident {

    public static void main(String[] args) {
        List<String> allResident = null;
        allResident.add("Resident1");
        allResident.add("Resident2");
        allResident.add("Resident3");
        allResident.add("Resident4");

        for (String resident : allResident) {
            switch (resident){
                case "Resident1":FruitStore.getInstance();
                case "Resident2":FruitStore.getInstance();
                case "Resident3":FruitStore.getInstance();
                case "Resident4":FruitStore.getInstance();
            }
        }
    }
}

老乡 (单例）

// 常见的双重校验写法
public class FruitStore{
    private static volatile FruitStore INSTANCE;
    private FruitStore(){
        //私有构造函数
    }
    public static FruitStore getInstance(){
        if(INSTANCE == null){
            synchronized(FruitStore.class){
                if(INSTANCE == null){
                     INSTSANCE = new FruitStore();
                }
            }
        }
        return INSTANCE;
    }
}

使用实例

下面以activity管理类功能来理解一下，一般情况下我们的activity管理是一个频繁调用的统一资源类，在应用中也应该是唯一的存在。这种时候就可以使用单例模式了。

public class ActivityManager{
    private List<Activity> activities = new ArrayList<Activity>();
    private static volatile ActivityManager INSTANCE;
    private ActivityManager(){
        //私有构造函数
    }
    public static ActivityManager getInstance(){
        if(INSTANCE == null){
            synchronized(ActivityManager.class){
                if(INSTANCE == null){
                     INSTSANCE = new ActivityManager();
                }
            }
        }
        return INSTANCE;
    }
    
    public void addActivity(Activity activity) {
        activities.add(activity);
    }
    //       .....
}

kotlin写法

基础写法
对应java的饿汉式写法，在类创建的同时进行对象的创建，达到了线程安全的目的，但是如果构造的耗时较长的话，会影响类的加载时间。如果只进行类的装载，没有调用便会造成资源浪费。

object ShuaiGe{}

懒加载写法

对应java的懒汉式写法，在类的实例第一次被使用时创建，解决了资源浪费问题。但是多线程并发下会出现两个对象指向同一个instance，没有达到单例效果。

public class ShuaiGe{
    companion object{
        val instance by lazy(LazyThreadSafetyMode.NONE){
            ShuaiGe()
        }
    }
}

同步锁写法
对应Java的线程安全的懒汉式写法，通过Synchronized注解进行获取方法的同步限制，达到了线程安全的目的，代价就是所有的访问都成了同步。

class ShuaiGe{
     companion object{
        private var instance:ShuaiGe?=null
        @Synchronized
        fun get():ShuaiGe{
            if(null==instance) instance=ShuaiGe()
            return instance
        }
     }
}

双重校验写法

对应Java的双重DCL校验写法，通过先判断实例，在加同步锁，再判断实例，最后创建的方式实现了，达到了线程相对安全的目的，但是可能在遇到JVM指令重排序时会出现半个对象。

class ShuaiGe{
    companion object{
        val instance by lazy(LazyThreadSafetyMode.SYNCHRONIZED){
            ShuaiGe()
        }
    }
}

静态内部类
JVM在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类(Helper)的属性/方法被调用时才会被加载, 并初始化其静态属性(instance)。是一种推荐的单例写法，没有加锁, 线程安全, 用到时再加载, 并发行能高。

class ShuaiGe private constructor(){
    companion object{
        fun getInstance = Helper.instance
    }
    private object Helper{
        val instance = ShuaiGe()
    }
}

适用环境

1. 应用中某个实例对象需要频繁的被访问。
2. 应用中每次启动只会存在一个实例。

总结

不管以哪种形式实现单例模式，它们的核心原理是将构造函数私有化，并且通过静态公有方法获取一个唯一的实例，在这个获取的过程中必须保证线程的安全，同时也要防止反序列化导致重新生成实例对象。