android 设计模式 单例（Singleton）模式

android 设计模式 单例（Singleton）模式

设计模式：描述了软件设计过程中某一类常见问题的一般性的解决方案。（设计模式：就是灵活应用抽象类、接口解决常用问题）
每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。

面向对象设计模式：
描述了面向对象设计过程中、特定场景下、类与相互通信的对象之间常见的组织关系。
整个设计模式贯穿一个原理:
1、面对接口编程，而不是面对实现.
2、目标原则是: 降低耦合,增强灵活性.

设计模式：创建型模式 结构型模式 行为模式

volatite关键字：（多线程）
volatile int value
每次都都是value 主内存——缓存，从而保证值能实时更新
synchronized关键字：
加锁，多个线程同时访问同个变量，那应该给这个变量加个锁，第一个线程访问时，其他线程等待第一线程执行完才能访问
内存同步(一致性)，且保证线程互斥(互斥性)。

对一个全局对象或者类加锁时，对该类的所有对象都起作用

synchronized作用于静态方法和非静态方法的区别:
非静态方法:
给对象加锁(可以理解为给这个对象的内存上锁,注意 只是这块内存,其他同类对象都会有各自的内存锁),这时候
在其他一个以上线程中执行该对象的这个同步方法(注意:是该对象)就会产生互斥
静态方法:
相当于在类上加锁(*.class 位于代码区,静态方法位于静态区域,这个类产生的对象公用这个静态方法,所以这块
内存，N个对象来竞争), 这时候,只要是这个类产生的对象,在调用这个静态方法时都会产生互斥

static关键字：
声明变量在主内存上的唯一性，不能保证缓存与主内存变量值的一致性；除非变量的值是不可变的，即再加上final的修饰符，否则static声明的变量，不是线程安全的。
可见性的意思是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。

单例模式 Singleton Patter

应用场景：
1、需要保证操作的一致性，即间断性的操作时，每一次的操作结果会保留，下一次继续从上一次的间断点开始（I/O流，数据库链接、缓冲区等）。
2、逻辑上只能有一个实例
3、频繁的创建和使用消耗的资源较大。（I/O流、数据库链接）

单例模式的实现：
1、构造函数private化（即不对外开放）
2、通过一个静态方法或者枚举返回单例对象（通过public static方法返回）
3、确保单例类的对象有且只有一个，尤其是在多线程的环境下
4、确保单例类对象在反序列化时不会重新构建对象

单例模式创建方式：
饿汉、懒汉、双重校验锁、静态内部类和枚举

//饿汉
public class Singleton {
    private static Singleton instance = new Singleton();  //应用启动时加载并初始化
    private Singleton() {}

    public static Singleton newInstance() {
       return instance;
    }
}

//懒汉
public class Singleton {
    private static volatile Singleton instance = null;  
    private Singleton() {}

    public static Singleton newInstance() {
       if(instance == null){
          instance = new Singleton(); //延迟加载
       }
       return instance;
    }
}

//双重校验锁（多线程）
public class Singleton {
    private static volatile Singleton instance = null;  
    private Singleton() {}

    public static Singleton newInstance() {
       if(instance == null){
          synchronized(Singleton.class){ // 类锁
             if(instance == null){
                instance = new Singleton();
             }
          }
       }
       return instance;
    }
}

//静态内部类（多线程）-- android系统中应用较多
public class Singleton {
    //静态内部类，JVM装载该内部类时才会去创建Singleton，实现懒汉式的延迟加载和线程安全
    private static class SingletonHolder {
        public static Singleton instance = new Singleton();
    }
    private Singleton() {}

    public static Singleton newInstance() {
        return SingletonHolder.instance();
    }
}

public enum Singleton{
    instance; // 枚举元素，Singleton的实例
}

//泛型单例类
public class Student {
    private int age;
    private String name;
    private String gender;

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
}

public class City {
    private String name;
    private String addr;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAddr() {
        return addr;
    }
    public void setAddr(String addr) {
        this.addr = addr;
    }
}

public class Singleton<T> {
    private static final ConcurrentMap<Class, Object> map = new ConcurrentHashMap<>();

    public static<T> T getSingleton(Class<T> c){ //Class<T>代表类型T所对应的类
           Object ob = map.get(type);
             try{
                  if(ob==null){
                       synchronized(map) {
                           // 通过Class<T>类型变量c来创建具体类类型的对象实例
                           ob = c.newInstance(); 
                           map.put(type,ob);
                       }
                  }
             }catch(InstantiationException e) {
                  e.printStackTrace();
             }catch(IllegalAccessException e) {
                  e.printStackTrace();
             }
           return (T) ob;
      }

    public static<T> void Remove(Class<T> c){
           map.remove(c);   
      }
}

public class Test0{
    public void inputTest() {
           Student student = Singleton.getSingleton(Student.class);
           student.setName("王小明");
           student.setAge(3);
           City city = Singleton.getSingleton(City.class);
           city.setName("广州市");
           city.setAddr("市桥工业路");
        }  
}

public class Test1{
    public static void main(String[] args) {
       Test0 test = new Test0();
       test.inputTest();

           Student student = Singleton.getSingleton(Student.class);
       City city = Singleton.getSingleton(City.class);
           System.err.println(city.getName()+city.getAddr());
        } 
}