单例模式

三个要素

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-lock
public 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) ;
      }
  }

• 总结优缺点

  • 优点

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

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