单例设计模式

单例设计模式是指：保证整个程序中只有一个实例。

确保某个类有且只要一个对象的场景，避免产生过多对象消耗过多资源，或者某个类型的对象有且只有一个。

Paste_Image.png
Paste_Image.png

实现形式有很多种，只要保证有单个实例就行，单例又分为懒汉式和饿汉式两种。
实现形式一：静态内部类

public class Single{
           private Single() {
       }

     public static SinglegetInstance(){
    return SingleHolder.mInstance;
   }

    public static class SingleHolder{
       private static volatile Single mInstance = new Single();
   }
}

实现形式二：容器管理

public class Single{
private static Map<String,Object> mSingleMap = new HashMap<>();

static {
    mSingleMap.put("activity_manager",new Single());
}

private Singleton() {

}

public static Object getService(String serviceName){
    return mSingleMap.get(serviceName);
}
 }

实现形式三：饿汉式

   public class Single{
  private static Single  mInstance = new Single();

  private Single(){

  }
   public static Single  getInstance(){
    return mInstance;
  }
  }

实现形式四：饿汉式

   public class Single{
           private static Single   mInstance;

        private  Single(){

             }
     public static synchronized Single  getInstance(){
       if(mInstance == null){
        mInstance = new Single();
     }
     return mInstance;
      }
  }

实现方式四存在一些问题，使用同步锁（DCL）

  public class Single3 {
    private static Single3 mInstance;
    private Single3() {
         }
  public static Single3 getInstance() {
      if (mInstance == null) {
          synchronized (Single3.class) {
            if (mInstance == null) {
                mInstance = new Single3();
            }
        }
    }
    return mInstance;
}

}
多线程并发的问题,如果多线程调用还是会存在多个实例

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

volatile 关键字的作用

防止重排序

线程可见性 - 某一个线程改了公用对象（变量），短时间内另一个线程可能是不可见的，因为每一个线程都有自己的缓存区（线程工作区）

Activity管理类实现

  public class AppManager {
   //Stack集合增加删除快
  private static Stack<Activity> activityStack;
  private static volatile AppManager instance;

private AppManager(){

    if(activityStack==null){
        activityStack=new Stack<Activity>();
    }

}
/**
 * 单一实例
 */
public static AppManager getAppManager(){

    if (instance == null) {
        synchronized (AppManager.class) {
            if (instance == null) {
                instance = new AppManager();
            }
        }
    }
    return instance;
}
/**
 * 添加Activity到堆栈
 */
public void addActivity(Activity activity){
    activityStack.add(activity);
}
/**
 * 获取当前Activity（堆栈中最后一个压入的）
 */
public Activity currentActivity(){
    Activity activity=activityStack.lastElement();
    return activity;
}
/**
 * 结束当前Activity（堆栈中最后一个压入的）
 */
public void finishActivity(){
    Activity activity=activityStack.lastElement();
    finishActivity(activity);
}
/**
 * 结束指定的Activity
 */
public void finishActivity(Activity finishActivity){

    int size = activityStack.size();
    for (int i = 0; i < size; i++) {
        Activity activity = activityStack.get(i);
        if (activity == finishActivity) {
            activityStack.remove(i);
            activity.finish();
            i--;
            size--;
        }
    }
}


/**
 * 结束指定类名的Activity
 */
public void finishActivity(Class<?> cls){

    int size = activityStack.size();
    for (int i = 0; i < size; i++) {
        Activity activity = activityStack.get(i);
        if (activity.getClass().getCanonicalName().equals(cls.getCanonicalName())) {
            activityStack.remove(i);
            activity.finish();
            i--;
            size--;
        }
    }

}
/**
 * 结束所有Activity
 */
public void finishAllActivity(){

    int size = activityStack.size();
    for (int i = 0; i < size; i++) {
        if (null != activityStack.get(i)) {
            activityStack.remove(i);
            activityStack.get(i).finish();
            i--;
            size--;
        }
    }
    activityStack.clear();

}
/**
 * 退出应用程序
 */
public void AppExit(Context context) {
    try {
        finishAllActivity();
        ActivityManager activityMgr= (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        activityMgr.restartPackage(context.getPackageName());
        System.exit(0);
    } catch (Exception e) {
    }
}

}