Android 单利模式(分类解析)

静态内部类
推荐使用

/**
 * 静态内部类
 */
public class Singleton {


    public Singleton(){}

    private static class Singlentoninstense{
        private static final Singleton INSTANCE=new Singleton();
    }

    public  static Singleton getInstance(Context context){
         Toast.makeText(context, "sssss", Toast.LENGTH_SHORT).show();
        return Singlentoninstense.INSTANCE;
    }
}

优点
在类第一次加载的时候进行初始化,所以虚拟机保证了线程的安全,再类进行初始化的时候别的先线程无法进入

使用场景
需要频繁的进行创建与销毁的对象
创建对象是耗时过多或者消耗资源过多,但是又经常用到的对象
工具类对象
频繁访问数据库或者文件的对象

饿汉式单利模式

 /**
  * 饿汉式(静态长量)
  */

    private final  static Singleton INSTANCE=new Singleton();

    private Singleton(){}

    private static Singleton getInstance(){
        return INSTANCE;
    }

优点
这种写法很简单,再类装载的时候就进行初始化,避免了线程同步的问题;
缺点
在类装载的时候就进行初始化,没有起到Lazy Loading的效果,如果从始至终没有使用过这个实例,则回造成内存浪费（如果用静态代码块的方式优点和缺点一样,只不过将实例方到静态代码块中）

懒汉式单利模式

    /**
     *
     * 懒汉式(线程不安全)
     */

    private static Singleton singleton;

    private Singleton(){}

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

优点
这种写法起到了Lazy Loading的效果
缺点
这种写法只能在单线程模式下使用,如果多线程模式下一个线程进入了if(singleton==null)判断语句,还没有来得及执行其他线程就已经通过了这个判断语句,这个时候就会产生多个实例,所以多线程模式下不实用这个方式

双重检查锁单利模式（推荐使用）

 /**
  *
 * 双重检查锁
*/
    private static volatile Singleton singleton;

    private  Singleton(){}

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

首先说一下volatile 不说我也忘了
第一点就是保证此变量对所有的线程的可见性，这里的“可见性”，当一个线程修改了这个变量的值，volatile 保证了新值能立即同步到主内存，以及每次使用前立即从主内存刷新。
第二点禁止指令重排序优化。（什么是指令重排序：是指CPU采用了允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理）
优点
这种方式线程安全,延迟加载,效率较高, 他进行了两次if(singleton==null)检查这样保证了线程安全这样实例化代码只执行一次后面再次访问时进行判读然后直接return实例化对象

枚举
这里就不进行推荐了
备注：Android整体不推荐枚举类型，因为占用内存过大，所以第八种枚举类型不可使用。

下面可不看------------------------------------------------------------------------------------

public class ResultUtils {
    private ResultBeanDao dao;

    private ResultUtils() {}

    private static ResultUtils mResultUtils = null;

    public static ResultUtils getResultUtils() {
        synchronized (ResultUtils.class) {
            if (mResultUtils == null) {
                mResultUtils = new ResultUtils();
            }
        }

        return mResultUtils;
    }






    //一定要记得初始化
    public void init(Context context) {
        DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(context, "result");
        SQLiteDatabase db = helper.getWritableDatabase();
        DaoMaster daoMaster = new DaoMaster(db);
        dao = daoMaster.newSession().getResultBeanDao();
    }

    /*

    1  7
    2  6
    3
    4
    5
    6
    7

    * */
    //添加
    public void add(ResultBean bean) {
        List<ResultBean> list = dao.loadAll();
        for (int i = 0; i < list.size(); i++) {
            ResultBean bean1 = list.get(i);
            if (bean.getCommodityId() == bean1.getCommodityId()) {
                dao.delete(bean1);
            }
        }
        dao.insert(bean);
    }

    //查询全部
    public List<ResultBean> loadAll() {
        List<ResultBean> listTemp=new ArrayList<>();
        List<ResultBean> list = dao.loadAll();
        for (int i = 0; i <list.size() ; i++) {
           ResultBean bean= list.get(i);
            listTemp.add(0,bean);
        }
        return listTemp;
    }
}

可能会产生多个实例

有些时候在软件开屏的时候就会出现网络请求弹出AlertDialog就会出现AlertDialog重叠的现象
我们可以用单利模式进行设置AlertDialog 上代码

public class MSDialogManager  {

    private static MSDialogManager msDialogManager = new MSDialogManager();
    private AlertDialog alertDialog;
    private TextView textView;
    String url = "https://yooul.com/yooul.apk";
    private TextView tv_cancel;
    private LinearLayout lin_text;
    private TextView tv_update;
    private TextView update_title;



    public static MSDialogManager newInstance() {
        return msDialogManager;
    }

    public void showDialog(Context context, int upgrade_type, String upgrade_point, String app_version) {
        if (alertDialog == null) {

            AlertDialog.Builder builder = new AlertDialog.Builder(context, R.style.dialogs);
            View view = View.inflate(context, R.layout.update_dialog, null);
            builder.setView(view);
            alertDialog = builder.create();
            /*alertDialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
                @Override
                public void onDismiss(DialogInterface dialogInterface) {
                    alertDialog = null;
                }
            });*/
            final RxPermissions rxPermissions = new RxPermissions((Activity) context);
            rxPermissions.request(Manifest.permission.RECORD_AUDIO,Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    .subscribe(new Action1<Boolean>() {
                        @Override
                        public void call(Boolean granted) {
                            if (granted) { // 在android 6.0之前会默认返回true


                            } else {


                            }
                        }
                    });
            tv_update = view.findViewById(R.id.tv_update);
            lin_text = view.findViewById(R.id.lin_text);
            tv_cancel = view.findViewById(R.id.tv_cancel);
            update_title = view.findViewById(R.id.update_title);
            TextView tv_info = view.findViewById(R.id.tv_info);
            tv_info.setText("新版本v"+app_version);

            //取消更新的按钮
            tv_cancel.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    alertDialog.dismiss();
                }
            });
            tv_cancel.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    alertDialog.dismiss();
                }
            });

            //版本更新词条
            String upgrade_points="1.优化细节和体验,更加稳定\n2.引入大量优质用户\n3.修复已知问题\n4.风格修改";
            if (upgrade_point!=null){
                update_title.setVisibility(View.VISIBLE);
                lin_text.setVisibility(View.GONE);
                update_title.setText(upgrade_point.replace("\\n", "\n"));
            }else {
                update_title.setVisibility(View.GONE);
                lin_text.setVisibility(View.VISIBLE);
                List<String> listtag = new ArrayList<>();
                listtag.add("1.优化细节和体验,更加稳定");
                listtag.add("2.引入大量优质用户");
                listtag.add("3.修复已知问题");
                listtag.add("4.风格修改");
                for (int i = 0; i < listtag.size(); i++) {
                    textView = new TextView(context);
                    textView.setTextColor(ContextCompat.getColor(context, sakura.bottommenulibrary.R.color.bottom_menu_layout_colors));
                    textView.setTop(5);
                    textView.setText(listtag.get(i));
                    lin_text.addView(textView);
                }
            }

            tv_update.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                     alertDialog.dismiss();
                    AppDownloadUtils.getInstance(AppManager.getAppManager().currentActivity()).setDownUrl(url).start();

                }
            });
        }

        if (upgrade_type==1){
            tv_cancel.setVisibility(View.GONE);
            alertDialog.setCanceledOnTouchOutside(true);
            alertDialog.setCancelable(true);
        }else if (upgrade_type==0){
            tv_cancel.setVisibility(View.VISIBLE);
            alertDialog.setCanceledOnTouchOutside(true);
            alertDialog.setCancelable(true);
        }
         if (PreferenceUtil.getInstance().isHomeHeaderFirst()) {
             alertDialog.dismiss();
         }else {
             if (AppDownloadUtils.getInstance(context).isLoad()){
                 alertDialog.dismiss();
             }else {
                 alertDialog.show();
             }
         }

       //alertDialog.show();
    }

    public void dismissDialog () {
        if (alertDialog != null) {
            alertDialog.dismiss();
            alertDialog = null;

        }
    }
}