今天我来全面总结一下Android开发中最常用的设计模式 - 单例模式。
关于设计模式的介绍，可以看下我之前写的：1分钟全面了解“设计模式”
其中，仓库类里的quantity=商品数量；工人类里有搬运方法MoveIn(int i)和MoveOut(int i)。
出现的问题：通过测试发现，每次工人搬运操作都会新建一个仓库，就是货物都不是放在同一仓库，这是怎么回事呢？（看下面代码） package scut.designmodel.SingletonPattern; //仓库类 class StoreHouse { private int quantity = 100; public void setQuantity(int quantity) { this.quantity = quantity; } public int getQuantity() { return quantity; } } //搬货工人类 class Carrier{ public StoreHouse mStoreHouse; public Carrier(StoreHouse storeHouse){ mStoreHouse = storeHouse; } //搬货进仓库 public void MoveIn(int i){ mStoreHouse.setQuantity(mStoreHouse.getQuantity()+i); } //搬货出仓库 public void MoveOut(int i){ mStoreHouse.setQuantity(mStoreHouse.getQuantity()-i); } } //工人搬运测试 public class SinglePattern { public static void main(String[] args){ StoreHouse mStoreHouse1 = new StoreHouse(); StoreHouse mStoreHouse2 = new StoreHouse(); Carrier Carrier1 = new Carrier(mStoreHouse1); Carrier Carrier2 = new Carrier(mStoreHouse2); System.out.println("两个是不是同一个？"); if(mStoreHouse1.equals(mStoreHouse2)){//这里用equals而不是用 == 符号，因为 == 符号只是比较两个对象的地址 System.out.println("是同一个"); }else { System.out.println("不是同一个"); } //搬运工搬完货物之后出来汇报仓库商品数量 Carrier1.MoveIn(30); System.out.println("仓库商品余量："+Carrier1.mStoreHouse.getQuantity()); Carrier2.MoveOut(50); System.out.println("仓库商品余量："+Carrier2.mStoreHouse.getQuantity()); } }结果：
两个是不是同一个？ 不是同一个 仓库商品余量：130 仓库商品余量：50实现1个类只有1个实例化对象 & 提供一个全局访问点
保证1个类只有1个对象，降低对象之间的耦合度
从上面可看出：工人类操作的明显不是同一个仓库实例，而全部工人希望操作的是同一个仓库实例，即只有1个实例
在Java中，我们通过使用对象（类实例化后）来操作这些类，类实例化是通过它的构造方法进行的，要是想实现一个类只有一个实例化对象，就要对类的构造方法下功夫：
单例模式的一般实现：（含使用步骤）
public class Singleton { //1. 创建私有变量 ourInstance（用以记录 Singleton 的唯一实例） //2. 内部进行实例化 private static Singleton ourInstance = new Singleton(); //3. 把类的构造方法私有化，不让外部调用构造方法实例化 private Singleton() { } //4. 定义公有方法提供该类的全局唯一访问点 //5. 外部通过调用getInstance()方法来返回唯一的实例 public static Singleton newInstance() { return ourInstance; } }好了，单例模式的介绍和原理应该了解了吧？那么我们现在来解决上面小成出现的“仓库不是一个”的问题吧！
小成使用单例模式改善上面例子的代码：
package scut.designmodel.SingletonPattern; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; //单例仓库类 class StoreHouse { //仓库商品数量 private int quantity = 100; //自己在内部实例化 private static StoreHouse ourInstance = new StoreHouse();; //让外部通过调用getInstance()方法来返回唯一的实例。 public static StoreHouse getInstance() { return ourInstance; } //封闭构造函数 private StoreHouse() { } public void setQuantity(int quantity) { this.quantity = quantity; } public int getQuantity() { return quantity; } } //搬货工人类 class Carrier{ public StoreHouse mStoreHouse; public Carrier(StoreHouse storeHouse){ mStoreHouse = storeHouse; } //搬货进仓库 public void MoveIn(int i){ mStoreHouse.setQuantity(mStoreHouse.getQuantity()+i); } //搬货出仓库 public void MoveOut(int i){ mStoreHouse.setQuantity(mStoreHouse.getQuantity()-i); } } //工人搬运测试 public class SinglePattern { public static void main(String[] args){ StoreHouse mStoreHouse1 = StoreHouse.getInstance(); StoreHouse mStoreHouse2 = StoreHouse.getInstance(); Carrier Carrier1 = new Carrier(mStoreHouse1); Carrier Carrier2 = new Carrier(mStoreHouse2); System.out.println("两个是不是同一个？"); if(mStoreHouse1.equals(mStoreHouse2)){ System.out.println("是同一个"); }else { System.out.println("不是同一个"); } //搬运工搬完货物之后出来汇报仓库商品数量 Carrier1.MoveIn(30); System.out.println("仓库商品余量："+Carrier1.mStoreHouse.getQuantity()); Carrier2.MoveOut(50); System.out.println("仓库商品余量："+Carrier2.mStoreHouse.getQuantity()); } }结果：
两个是不是同一个？ 是同一个 仓库商品余量：130 仓库商品余量：80从结果分析，使用了单例模式后，仓库类就只有一个仓库实例了，再也不用担心搬运工人进错仓库了！！！
这是 最简单的单例实现方式
原理 依赖 JVM类加载机制，保证单例只会被创建1次，即 线程安全 JVM在类的初始化阶段(即 在Class被加载后、被线程使用前)，会执行类的初始化在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化 具体实现 class Singleton { // 1. 加载该类时，单例就会自动被创建 private static Singleton ourInstance = new Singleton(); // 2. 构造函数 设置为 私有权限 // 原因：禁止他人创建实例 private Singleton() { } // 3. 通过调用静态方法获得创建的单例 public static Singleton newInstance() { return ourInstance; } } 应用场景 除了初始化单例类时 即 创建单例外，继续延伸出来的是：单例对象 要求初始化速度快 & 占用内存小单元素的枚举类型已经成为实现 Singleton的最佳方法
与 饿汉式 最大的区别是：单例创建的时机
饿汉式：单例创建时机不可控，即类加载时 自动创建 单例懒汉式：单例创建时机可控，即有需要时，才 手动创建 单例 具体实现 class Singleton { // 1. 类加载时，先不自动创建单例 // 即，将单例的引用先赋值为 Null private static Singleton ourInstance = null； // 2. 构造函数 设置为 私有权限 // 原因：禁止他人创建实例 private Singleton() { } // 3. 需要时才手动调用 newInstance（） 创建 单例 public static Singleton newInstance() { // 先判断单例是否为空，以避免重复创建 if( ourInstance == null){ ourInstance = new Singleton(); } return ourInstance; } } 缺点 基础实现的懒汉式是线程不安全的，具体原因如下 下面，将对懒汉式 进行优化，使得适合在多线程环境下运行实际上只需在第1次调用该方法时才需要同步，一旦单例创建成功后，就没必要进行同步
原理 在同步锁的基础上，添加1层 if判断：若单例已创建，则不需再执行加锁操作就可获取实例，从而提高性能
具体实现
class Singleton { private static Singleton ourInstance = null； private Singleton() { } public static Singleton newInstance() { // 加入双重校验锁 // 校验锁1：第1个if if( ourInstance == null){ // ① synchronized (Singleton.class){ // ② // 校验锁2：第2个 if if( ourInstance == null){ ourInstance = new Singleton(); } } } return ourInstance; } } // 说明 // 校验锁1：第1个if // 作用：若单例已创建，则直接返回已创建的单例，无需再执行加锁操作 // 即直接跳到执行 return ourInstance // 校验锁2：第2个 if // 作用：防止多次创建单例问题 // 原理 // 1. 线程A调用newInstance()，当运行到②位置时，此时线程B也调用了newInstance() // 2. 因线程A并没有执行instance = new Singleton();，此时instance仍为空，因此线程B能突破第1层 if 判断，运行到①位置等待synchronized中的A线程执行完毕 // 3. 当线程A释放同步锁时，单例已创建，即instance已非空 // 4. 此时线程B 从①开始执行到位置②。此时第2层 if 判断 = 为空（单例已创建），因此也不会创建多余的实例 缺点 实现复杂 = 多种判断，易出错