单例模式

三个要素

1、私有的构造方法

2、指向自身的静态实例引用

3、公有的静态的获取自身实例方法

• UML类图

  
  

  UML类图

• 定义

  单例模式说的是该类只有一个实例，实现的关键是将该类的构造方法私有化，提供一个静态获取该实例

• 使用场景

  确保某个类有且只有一个对象的场景，例如创建一个对象需要消耗的资源过多，如要访问 IO 和数据库等资源。

饿汉式

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

懒汉式

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

但是以上方式在多线程环境下会出现问题，可能会new出来多个实例。
固需加锁，但是直接在方法上加synchronized关键字，每次获取实例都会加锁，而事实上只需在创建实例的时候才需加锁。故将getInstance方法改成如下：

public static Singleton getInstance() {        if (singleton== null) {            synchronized (singleton) {                if (singleton== null) {                    singleton= new Singleton();                }            }        }        return singleton;    }

当然也可以将创建实例的过程与获取实例的过程分开。

懒汉式与饿汉式的区别：

1. 懒汉式是延迟加载的，当使用到单例时才开始实例化，而饿汉式是程序开启就实例化完成了。
2. 懒汉式不是线程安全的，而饿汉式线程安全。

单例模式一般在缓存的时候使用，当某些外部资源频繁的被使用时，可以先将这些资源读到内存中，下次访问的时候就可以直接从内存中读取了，这样就可以节省大量的时间。在Android开发中解析配置文件的Manager、Sharepreference的管理器一般都是使用单例。缓存是一种典型的空间换时间的方案。

实际项目应用:TreeAccessoryStateManager

public class TreeAccessoryStateManager {    public static final int ACCE_STATUS_NOT_BUY = 0;    public static final int ACCE_STATUS_BOUGHT_NOT_USE = 1;    public static final int ACCE_STATUS_BOUGHT_USE = 2;    // 此处使用饿汉式单例，主要是为了确保线程安全    private static final TreeAccessoryStateManager instance = new TreeAccessoryStateManager();    public static TreeAccessoryStateManager getInstance() {        return instance;    }    private Map<Integer, GoodsItem> accessoryMap;    private TreeAccessoryStateManager() {        //由于这个map在主线程和render thread都有频繁改动，改成ConcurrentHashMap，暂时避免大部分问题。        accessoryMap = new ConcurrentHashMap<Integer, GoodsItem>();    }    public int getAcceStatus(int acceId) {        GoodsItem goodsItem = accessoryMap.get(acceId);        if (goodsItem != null) {            return goodsItem.getStatus();        }        return ACCE_STATUS_NOT_BUY;    }}

3.静态内部类

//静态内部类public class Singleton {    private static class SingletonHolder {        private static final Singleton singleton = new Singleton();    }    private Singleton() {    }    public static Singleton getSingleton() {        return SingletonHolder.singleton;    }}

---

4.枚举

//枚举public enum Singleton {    INSTANCE;    public void whateverMethod() {    }}

---

5.double-lock

//double-lockpublic class Singleton {    private volatile static Singleton singleton;    private Singleton() {    }    public static Singleton getSingleton() {        if (singleton == null) {            synchronized(Singleton.class) {                if (singleton == null) {                    singleton = new Singleton();                }            }        }        return singleton;    }}

• 容器方式

  注册到容器, 根据key获取对象.一般都会有多种相同属性类型的对象会注册 到一个map中，实现代码如下：

  public class Singleton {    private static Map<string singleton=""> objMap = new HashMap<string singleton="">();      /**     * 注册对象到map中     * @param key     * @param instance     */    public static void registerService(String key, Singleton instance) {        if (!objMap.containsKey(key) ) {             objMap.put(key, instance) ;        }    }    /**     * 根据key获取对象     * @param key     * @return     */    public static Singleton getService(String key) {        return objMap.get(key) ;    }}

• 总结优缺点

  • 优点

    • 由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。
    • 由于单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决；
    • 单例模式可以避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
    • 单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

  • 缺点
    单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。