[干货]设计模式：六种单例的创建方式，外加一大波Android进阶架构师资料分享

Posted 2021-06-02 斯音

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了[干货]设计模式：六种单例的创建方式，外加一大波Android进阶架构师资料分享相关的知识，希望对你有一定的参考价值。

单例模式的定义

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

六种单例的创建方式

1.饿汉式

public class Singleton {
  private static Singleton instance = new Singleton();
  private Singleton() {}
  public static Singleton getInstance() {
    return instance;
  }
}

优点：基于类的加载机制，避免了多线程同步问题，加载速度快。

缺点：在类加载的时候就完成初始化，没有懒加载，如果没有使用这个实例，会造成内存浪费。

2.懒汉式-线程不安全版

public class Singleton {
  private static Singleton instance;
  private Singleton() {}
  public static Singleton getInstance() {
    if(instance == null){
      instance = new Singleton();
    }
    return instance;
  }
}

优点：第一次调用是才初始化对象，避免浪费资源

缺点：加载速度慢，线程不安全

3.懒汉式-线程安全版(synchronized加锁)

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

优点：多线程中保证线程安全缺点：每次获取对象实例，都需要进行同步，造成不必要的同步开销。

4.双重校验锁

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

优点：线程安全，懒加载，减少同步开销

缺点：第一个获取对象速度稍慢，但其在某些情况下也会出现失效的情况，并不是完美的方式。

这里面使用了两次判空：第一次为了不必要的加锁同步，第二次是确保在instance为null的情况下才创建实例，避免多次创建。

方法中还是用了关键字volatile对变量进行修饰，有如下几个作用：

1.在Java内存模型中volatile可以保证可见性，及防止程序指令重排序。

2.对象的创建分为如下几个步骤：

instance = new Singleton（）；

1.为instance分配内存空间
2.初始化instance
3.将instance指向内存地址
如果不加volatile的话，程序的执行顺序就可能变成1->3->2,多线程中就会导致线程获取一个没有初始化的实例。例如线程a 执行了1，3, 此时线程b调用getInstance()发现instance不为空，返回instance,但此时instance还未初始化。

单例模式

单例设计模式：保证一个类仅有一个实例，并且提供一个访问它的全局访问点。有些对象只需要一个，这时可用单例模式。

传统的单例模式和new 创建对象的调用不一样
调用者要调用xxx.getInstance才能获得该单例

function Singleton(name) {
    this.name = name;
}
Singleton.getInstance = function (name) {
    if(this.instace){
        return this.instace;
    }else {
        this.instace = new Singleton(name);
        return this.instace;
    }
};
var a = Singleton.getInstance('a');
var b = Singleton.getInstance('b');
console.log(a===b); //true

5."透明"的单例模式

透明”的单例类，用户从这个类中创建对象的时候，可以像使用其他任何普通类一样
直接 new 一个对象
不能new 多个对象，扩展性不好

var instace;
function Person(name) {
    this.name = name;
    if (!instace) {
        instace = this;
    }
    return instace;
}

Person.prototype.getName = function () {
    console.log(this.name);
};
var a = new Person('a');
var b = new Person('b');
console.log(a===b);

6.代理模式创建单例模式

代理模式:自己不去做，委托中间人做
Person是一个普通类，通过new Person可以创建一个对象
用代理模式创建CreateSinglePerson方法，通过new CreateSinglePerson可以创建一个单例

function Person(name) {
    this.name = name;
}
Person.prototype.getName = function () {
    console.log(this.name);
};
var CreateSinglePerson = (function (name) {
    var instance;
    return function () {
        if (!instance) {
            instance = new Person(name);
        }
        return instance;
    };
})();
var a = new CreateSinglePerson('a');
var b = new CreateSinglePerson('b');
console.log(a === b);
var c = new Person('c');
var d = new Person('d');
console.log(c === d);

javascript中的单例模式

单例模式的核心是确保只有一个实例，并提供全局访问
在JavaScript可以通过直接创建一个对象来实现单例模式
可以用闭包的方式实现私有变量

let MyApp = {
  name:'app',
  getName:function() {
    console.log(this.name);
  }  
};
let MyApp2 = (function(){
    var _name = 'app';
    return {
        getName:function() {
            console.log(_name);
        } 
    }
})();

#####惰性单例

惰性单例是指在需要的时候才创建
🌰：调用render方法，创建A对象，可以多次调用render方法，A对象是单例的

var createA = (function () {
    var instance;
    return function () {
        if(!instance){
            //xxx
            instance = 'A';
        }
        return instance;
    };
})();
function render() {
    createA();
    console.log('b');
}
render();
render();

如果要创建B对象，B也是单例

var createB = (function () {
    var instance;
    return function () {
        if(!instance){
            //xxx
            instance = 'B';
        }
        return instance;
    };
})();

我们看到createA和createB的核心代码是相同的，所以可以抽离出通用创建的惰性单例的代码

function getSingleton(fn) {
  var result;
  return function() {
    return result||(result = fn.apply(this,arguments));
  }
} 
var createA = function () {
    var instance;
    if(!instance){
        //xxx
        instance = 'A';
    }
    return instance;
};
var createB = function () {
    var instance;
    if(!instance){
        //xxx
        instance = 'B';
    }
    return instance;
};
var createASingle = getSingleton(createA);
var createBSingle = getSingleton(createB);
function render() {
    createASingle();
    createBSingle();
}
render();
render();

小结
单例模式用到了闭包和高阶函数的特性。单例模式是简单但常用到的模式，比如单页应用、websocket连接等等。特别是惰性单例模式，用到时才创建，再次用到是不需要再次创建。创建对象和管理单例的职责分布在不同的方法中，方便扩展和管理。