前言
在实际应用中，使用singleinstance启动模式时，会遇到一些奇奇怪怪的问题。Android有四种启动模式，分别是standard，singleTop，singleTask，singleInstance。下面分别简单的介绍下这四种启动模式的作用。
standard
Android 默认的一种启动模式。不需要为activity设置launchMode。这种启动模式简单的来说就是当你startActivity的时候，他就创建一个。
singleTop
这种模式模式从字面意思就能看得出来，就是当前的activity处于栈顶的时候，当你startActivity当前的activity的时候，它不会创建新的activity，而是会复用之前的activity。举个例子，startActivity了一个ActivityA，ActivityA又startActivity了ActivityB，当在ActivityB再次startActivity一个ActivityB的时候，它不会创建一个新的ActivityB，而是复用之前的ActivityB。

这里需要注意的是，只有当前的activity处于栈顶的时候才管用。举个例子：startActivity了一个ActivityA，ActivityA又startActivity了ActivityB，ActivityB又startActivity了ActivityA，那么ActivityA还是会重新创建，而不是复用之前的ActivityA。
singleTask
单一任务。意思就是说当前的activity只有一个实例，无论在任何地方startActivity出来这个activity，它都只存在一个实例。并且，它会将在他之上的所有activity都销毁。通常这个activity都是用来作为MainActivity。因为主页只需要存在一个，然后回到主页的时候可以将所有的activity都销毁起到退出应用的作用。举个例子，startActivity了一个ActivityA，ActivityA的启动模式为singleTask，那么在ActivityA里startActivity了一个ActivityB，在ActivityB里startActivity了一个ActivityC。此时在当前的任务栈中的顺序是，ActivityA->ActivityB->ActivityC。然后在ActivityC里重新startActivity了一个ActivityA，此时ActivityA会将存在于它之上的所有activity都销毁。所以此时任务栈中就只剩下ActivityA了。
singleInstance
这个模式才是重点，也是比较容易入坑的一种启动模式。字面上理解为单一实例。它具备所有singleTask的特点，唯一不同的是，它是存在于另一个任务栈中。上面的三种模式都存在于同一个任务栈中，而这种模式则是存在于另一个任务栈中。举个例子，上面的启动模式都存在于地球上，而这种模式存在于火星上。整个Android系统就是个宇宙。下面来详细介绍一下singleInstance的坑。
singleInstance之一坑
此时有三个activity，ActivityA，ActivityB，ActivityC，除了ActivityB的启动模式为singleInstance，其他的启动模式都为默认的。startActivity了一个ActivityA，在ActivityA里startActivity了一个ActivityB，在ActivityB里startActivity了一个ActivityC。此时在当前的任务栈中的顺序是，ActivityA->ActivityB->ActivityC。照理来说在当前ActivityC页面按返回键，finish当前界面后应当回到ActivityB界面。但是事与愿违，奇迹出现了，页面直接回到了ActivityA。这是为什么呢？其实想想就能明白了，上面已经说过，singleInstance模式是存在于另一个任务栈中的。也就是说ActivityA和ActivityC是处于同一个任务栈中的，ActivityB则是存在另个栈中。所以当关闭了ActivityC的时候，它自然就会去找当前任务栈存在的activity。当前的activity都关闭了之后，才会去找另一个任务栈中的activity。也就是说当在ActivityC中finish之后，会回到ActivityA的界面，在ActivityA里finish之后会回到ActivityB界面。如果还想回到ActivityB的页面怎么办呢？我的做法是，在ActivityB定义一个全局变量，public static boolean returnActivityB;界面需要跳转的时候将returnActivityB=true;然后在ActivityA界面onstart方法里判断returnActivityB是否为true，是的话就跳转到ActivityB，同时将returnActivityB=false;这样就能解决跳转的问题了。不过感觉还不是很好，如果有更好的方法，欢迎大家给我留言告诉我一声。
singleInstance之二坑
此时有两个个activity，ActivityA，ActivityB，ActivityA的启动模式为默认的，ActivityB的启动模式为singleInstance。当在ActivityA里startActivity了ActivityB，当前页面为ActivityB。按下home键。应用退到后台。此时再点击图标进入APP，按照天理来说，此时的界面应该是ActivityB，可是奇迹又出现了，当前显示的界面是ActivityA。这是因为当重新启动的时候，系统会先去找主栈（我是这么叫的）里的activity，也就是APP中LAUNCHER的activity所处在的栈。查看是否有存在的activity。没有的话则会重新启动LAUNCHER。要解决这个方法则是和一坑的解决办法一样，在ActivityB定义一个全局变量，public static boolean returnActivityB;在oncreat方法将returnActivityB=true;然后在ActivityA界面onstart方法里判断returnActivityB是否为true，是的话就跳转到ActivityB，同时将returnActivityB=false;这样就能解决跳转的问题了。
基友留言，确实发现了好多问题，所以在此更新2020/5/21
有许多好基友留言，我也确实发现以上的解决方案不是很好，也存在一些问题，所以我又想了另一种解决思路。代码在GitHub上LaunchModeDemo

首先先将每个创建的activity用一个单例类保存下来，接着再用这个单例类保存启动了singleInstance模式的activity。在oncreate()时put,在onDestroy和onBackPressed时remove。为什么要在这两个地方都删除，待会会说明，已经在remove方法里处理了重复删除的问题。

先贴上管理activity的类，也就是添加删除activity的单例类ActivityTaskManager
package com.example.launchmodedemo;

import android.app.Activity;
import java.util.concurrent.CopyOnWriteArrayList;

/** Activity栈管理类，当Activity被创建是压栈，销毁时出栈 */
public class ActivityTaskManager {

  private final CopyOnWriteArrayList<Activity> ACTIVITY_ARRAY = new CopyOnWriteArrayList<>();
  private final CopyOnWriteArrayList<Activity> SINGLE_INSTANCE_ACTIVITY_ARRAY =
      new CopyOnWriteArrayList<>();

  private static final Singleton<ActivityTaskManager> SINGLETON =
      new Singleton<ActivityTaskManager>() {
        @Override
        protected ActivityTaskManager create() {
          return new ActivityTaskManager();
        }
      };

  public static ActivityTaskManager getInstance() {
    return SINGLETON.get();
  }

  public void put(Activity targetActivity) {
    boolean hasActivity = false;
    for (Activity activity : ACTIVITY_ARRAY) {
      if (targetActivity == activity) {
        hasActivity = true;
        break;
      }
    }
    if (!hasActivity) {
      ACTIVITY_ARRAY.add(targetActivity);
    }
  }

  public void remove(Activity targetActivity) {
    for (Activity activity : ACTIVITY_ARRAY) {
      if (targetActivity == activity) {
        ACTIVITY_ARRAY.remove(targetActivity);
        break;
      }
    }
  }

  public void putSingleInstanceActivity(Activity targetActivity) {
    boolean hasActivity = false;
    for (Activity activity : SINGLE_INSTANCE_ACTIVITY_ARRAY) {
      if (targetActivity == activity) {
        hasActivity = true;
        break;
      }
    }
    if (!hasActivity) {
      SINGLE_INSTANCE_ACTIVITY_ARRAY.add(targetActivity);
    }
  }

  public void removeSingleInstanceActivity(Activity targetActivity) {
    SINGLE_INSTANCE_ACTIVITY_ARRAY.remove(targetActivity);
  }

  public CopyOnWriteArrayList<Activity> getSingleInstanceActivityArray() {
    return SINGLE_INSTANCE_ACTIVITY_ARRAY;
  }

  public Activity getTopActivity() {
    if (ACTIVITY_ARRAY.isEmpty()) {
      return null;
    }
    return ACTIVITY_ARRAY.get(0);
  }

  public Activity getLastActivity() {
    if (ACTIVITY_ARRAY.isEmpty()) {
      return null;
    }
    return ACTIVITY_ARRAY.get(ACTIVITY_ARRAY.size() - 1);
  }
}


Singleton
package com.example.launchmodedemo;

/**
 * 单例构建类
 */
public abstract class Singleton<T> {
    private T mInstance;

    protected abstract T create();

    public final T get() {
        synchronized (this) {
            if (mInstance == null) {
                mInstance = create();
            }
            return mInstance;
        }
    }
}


偷个懒，没什么注释，但是各位那么聪明应该看得懂。
然后贴上我的BaseActivity，基本上都是在这里处理的了
package com.example.launchmodedemo;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;

public class BaseActivity extends AppCompatActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ActivityTaskManager.getInstance().put(this);
  }

  private static final String TAG = "BaseActivity";

  @Override
  protected void onStart() {
    super.onStart();
    Log.i(
        TAG,
        "onStart: " + ActivityTaskManager.getInstance().getLastActivity().getClass().getName());
    checkActivityJump();
  }

  @Override
  public void onBackPressed() {
    super.onBackPressed();
    // 如果不在这里移除当前activity的话，在启动另一个界面的onStart的时候，判断处于栈顶的activity，
    // 也就是ActivityTaskManager.getInstance().getLastActivity()的时候，就会出现错误。
    // 原因是，当一个activity的onPause之后就会启动另一个activity，还没经历过onDestroy，
    // 而removeActivity();只放在onDestroy中的话就会在启动的activity的onStart
    // 获取ActivityTaskManager.getInstance().getLastActivity()返回的是错误。
    removeActivity();
  }

  private void checkActivityJump() {
    if (ActivityTaskManager.getInstance().getLastActivity() != null) {
      Log.i(
          TAG,
          "onStart: " + ActivityTaskManager.getInstance().getLastActivity().getClass().getName());
      // 如果当前的activity跟添加进去的最后一个activity不是同一个的话，那么这种哦情况就有可能是最后一个activity的启动模式是SingleInstance，
      // 所以这时候就要遍历添加进去的SingleInstanceActivityArray，看是否有存在，有的话并且跟最后一个添加进去的activity是同一个的话就跳转
      // 这里设置了跳转动画，是因为单例模式的跳转动画跟其他的模式不一样，看起来很难受，设置后看起来舒服些，也可以设置别的动画，
      // 退到后台再进来会一闪，十分明显，添加跳转动画看起来也会舒服些
      if (!ActivityTaskManager.getInstance()
          .getLastActivity()
          .getClass()
          .getName()
          .equals(this.getClass().getName())) {
        if (ActivityTaskManager.getInstance().getSingleInstanceActivityArray().size() > 0) {
          for (Activity activity :
              ActivityTaskManager.getInstance().getSingleInstanceActivityArray()) {
            if (activity
                .getClass()
                .getName()
                .equals(ActivityTaskManager.getInstance().getLastActivity().getClass().getName())) {
              ActivityTaskManager.getInstance().removeSingleInstanceActivity(activity);
              startActivity(
                  new Intent(this, ActivityTaskManager.getInstance().getLastActivity().getClass()));
              overridePendingTransition(0, 0);
              break;
            }
          }
        }
      }
    }
  }

  @Override
  protected void onStop() {
    super.onStop();
    Log.i(TAG, "onStop: " + this.getClass().getName());
  }

  @Override
  protected void onDestroy() {
    super.onDestroy();
    removeActivity();
  }

  /** 释放资源 */
  private void removeActivity() {
    ActivityTaskManager.getInstance().remove(this);
  }
}


在代码的注释已经解释了我的思路了。我简要说明一下，在onStart中判断，如果当前的activity跟添加进去的最后一个activity不是同一个的话，那么这种哦情况就有可能是最后一个activity的启动模式是SingleInstance，所以这时候就要遍历添加进去的SingleInstanceActivityArray，看是否有存在，有的话并且跟最后一个添加进去的activity是同一个的话就跳转。大家可以看看代码，在注释上写的很清楚的。最后附上代码地址，代码在GitHub上LaunchModeDemo
。
总结
Android的启动模式如果利用的好，还是可以解决很多问题的。启动模式还是值得好好的研究一下的。欢迎各位指教出错误，共同学习。如果有不对的地方，请大家指出，一起快乐的改bug。

温馨提示：  本贴适用于 Win10 UEFI 模式启动+双硬盘（固态硬盘+机械硬盘）安装 ubuntu18.04 双系统

本人电脑型号： 戴尔游匣5575 （128固态+1T机械硬盘），Win10UEFI启动模式，64位操作系统

ubuntu18.04下载链接：https://www.ubuntu.com/download/desktop

系统安装过程应注意的事项：

    1、安装原理

    2、安装环境

    3、安装过程

        3.1、安装环境配置

        3.2、分配硬盘安装空间

        3.3、制作启动U盘

        3.4、U盘启动安装

            3.4.1、基本步骤

            3.4.2、盘符选择

            3.4.3、分区挂载

        4、安装完成

1、安装原理：

        不管是单系统还是双系统，是legacy启动还是uefi启动，系统安装原理都是一样的，核心就是：系统部署+系统引导，电脑在启动后只有根据引导文件找到已经部署的系统才能正常启动。那些img、iso等各种类型的镜像文件，是系统的封装形式；进PE安装或者U盘、光盘启动盘安装，是系统的安装方式；用easyBCD、Bootice等工具修复系统引导，是改变系统的启动路径。

2、安装环境：

        安装双系统之前首先要了解自己电脑的软硬件环境，不同的软硬件环境搭配会导致不同的安装方法，这一点一定牢记！！网上有很多种安装教程，但是我们直接拿来用却不一定能成功，而且是往往不能成功，原因一般都不是这些教程本身有错误，而是因为其应用的环境与我们安装系统的软硬件环境有差异。 

　　我的环境是：uefi启动模式下的win10 + ubutu18.04，其中win10 安装在 128G固态硬盘上（这也是为啥现在win10 启动时间仅仅10 几秒的原因），Ubuntu18.04LTS 安装在1T 机械硬盘上

3、安装过程：

    3.1、环境配置

        开机按住 F2 进入  BOIS 设置（不同电脑品牌可能不太一样，有些品牌的电脑开机在右下角有提示，比如戴尔，具体方式自己百度） 用键盘上的方向键 右键 移动光标 到 Boot 选项 ，再用 键盘上的方向键 下键 移动光标至 Secure Boot 将其  Enabled  修改为 Disabled，（Secure Boot 是安全启动项，不关闭的安装到 选择安装类型时 会提提示输入 安全启动项 密码，这个东西打售后技术支持 他们也不会告诉你的，所以为避免不必要的麻烦，一定要记得关闭 安全启动项 ），如图所示：

进入 BOIS 界面：按下图设置：



完成上述修改后，按下 F10，按下图设置：



重启后，按 F2 进入 BIOS ,设置完成后 Boot 的界面如下图： 



这说明 Secure Boot 项设置完成，之后 按  ESC 退出 BOIS ,电脑重启

    3.2、 分配硬盘安装空间

        win10 自带分区功能，鼠标放在 此电脑 上 右键  选择  管理  ，打开界面后选择 磁盘管理  ，接下来在你的 机械硬盘  上  找到一个 容量比较大的磁盘  鼠标选中 容量比较大的磁盘  鼠标右键 压缩磁盘  ，至于压缩磁盘的 大小是自己的磁盘可用量而定  ，我的 压缩磁盘 210GB （刚开始只分配了 150GB ，后来发现不够用， 卸载重新 压缩磁盘 安装的，建议：如果磁盘容量足够大，可以压缩空间大于 200G ），如下图所示：

        注意： 压缩的磁盘空间  一定不要分配盘符（即  不要新建卷  ，也即是不需要盘符 D、 E、F这些东西，保持未分配状态）

查看 磁盘1 的分区方式 ，如下图：



压缩后的磁盘空间 210GB  状态 ： 未分配（不要新建卷，保持未分配状态）



磁盘空间分配完成

     3.3、制作启动U盘

            这一步很关键，若电脑是 UEFI 启动模式，而不是  传统的 Legacy 启动，制作的  启动U盘 也要选择 UEFI 启动模式  否则 无法启动

           还要注意磁盘的 分区表 是 GPT 还是 MBR ，MBR是旧的分区表形式，GPT 是新的分区表形式，至于二者的具体区别这里不多说，想了解的自行百度，若是 GPT 分区表，制作 U盘 时 就要选择 GPT  ，否则 无法启动

制作 启动U盘的工具 推荐这一款 :   下载链接：https://download.csdn.net/download/xrinosvip/10568860   （当然你也可以用其他U盘制作工具，自行百度）

            由于我的笔记本 是  UEFI模式启动，机械硬盘是  GPT 分区方案，故在制作  启动U盘  时，选择  用于UEFI计算机的GPT分区方案

        至于有些教程说 把 UEFI 模式 在 Boot 中修改为 Legacy 启动模式，对于UEFI 启动模式的 电脑，这是没必要的，这种方法陈旧了，对于新启动模式的电脑 早已不适用，而且就算安装成功，启动win10  和 Ubuntu 时，也要来回修改 Boot 下的 Boot List Option(启动模式），而且这种方法安装的双系统有一个 致命的缺点 就是容易出现 系统崩溃 ，况且 ubuntu18.04 LTS 也是长期支持版，本来就支持  UEFI 启动模式，而且 Legacy 模式 也无法 启动win10 ,具体制作过程如图下图所示：



设置：按照上述图片中的 红色箭头 标注处设置，其余选项默认就可以

    3.4、U盘启动安装

        3.4.1、基本步骤

            插入制作好的U盘，重启电脑，狂点F12（不同主板按键不同)进入Bootloader，找到自己  U盘  ，使用键盘上的方向键选中（有些教程说要设置  U盘启动  ，重启就自动进入安装界面，这一步不是必须的，只要找到自己的 U盘即可),，按下  Enter  ,即可进入  ubuntu18.04  的安装界面,  这里可以选择 试用（在试用界面里左边工具栏 有安装图标）， 当然也可选择  直接安装，至于选择哪种安装方式都是一样的，具体过程如下图所示：

按F12 进入启动项 ，选择制作的 安装U盘



选中 制作的 U盘  ，按下 Enter ,即可进入安装Ubuntu18.04 界面，会出现  试用不安装  和  直接安装

选择  试用不安装  进入下列界面：



下一步安装：



直接安装  和 试用不安装 进行上面两步操作后，都会进入下面界面：

选择安装语言，按图示操作即可：



下一步，选择键盘布局：



下一步，Updates and others software:



下一步，安装类型，一定要选择 something else:



下一步，分区挂载，这一步很关键：

 

          3.4.2、盘符选择

                    在原有系统上安装双系统有一个基本原则，那就是无论新系统是否安装成功，都不要破坏原系统环境，否则就是赔了夫人又折兵了。注意Ubuntu盘符的命名特点“sdxy”，其中x指物理磁盘号，y指磁盘的逻辑分区号，如sda1指第一块物理磁盘上的第一块逻辑分区，sdb2指第二块物理磁盘上的第二块逻辑分区。只要找准磁盘分区进行安装，原系统环境就不会被破坏，Ubuntu重装个十次八次的都有恃无恐。

压缩的分区如下图：



下一步

        3.4.3、分区挂载

                这一步非常重要！非常重要！非常重要！，这一步关系到  Ubuntu系统是否会覆盖掉自带的win10系统  ，也关系到  双系统能否安装成功  ，安装到   Installation type  这一步时，一定要慢慢来，选择   Something else  ,然后再点击   Continue ,(此处点击  Contiue 一定要慎重，并不是如某些教程所说的  一顿  Continue 狂点，狂点  Continue 造成的个人损失 本人概不负责），第一次安装一定要慢慢的按照步骤来操作      

我的安装方案： 

  ubuntu18.04只需挂载了 两个分区： 1、 挂载 /     2、 挂载 / home  分别分配空间  90GB 和 110GB 

"/"  是根目录，其他的分区会自动挂载到 "/" 根目录，所以 "/" 根目录需要多分配点空间("/"类似于Windows的 c 盘，所以这个目录下装的是系统的东西，如果你安装软件习惯默认安装，没有修改路径的习惯，建议 "/" 多分配点空间，因为默认安装的软件都被安装在 "/usr"目录里面)；

"/home" 是用户文件夹(类似于Windows中的 user，当然也可以理解为Windows里面的除 C盘以外的，D,E,F盘，如果安装软件习惯修改安装路径，完全可以将软件安装在"/home"目录下)，因此只需挂载这两个分区就够了，下面的挂载分区介绍 仅供参考，具体操作过程如下图所示：

挂载第一个分区， 挂载分区 /，这个  / 是根目录，类似于Windows 里面的 C 盘 :



下一步，在弹出来的界面，分配  挂载分区 / 大小：



 

第一个挂载分区  / ，完成，点击 OK

下一步，挂载分区 /home :



下一步，设置 挂载分区 /home 大小， /home 类似于Windows里面的 user文件夹或者 D、E、F盘：



 

挂载分区 /home 完毕，点击 OK, 还不能安装！！！

下一步，选择 将 Boot 安装在 Windows boot Manager 中：



下一步



下一步



下一步



下一步



下一步，进入 安装界面：



 

               挂载分区介绍：

                    1、挂载“/”，也叫根目录，类似于Windows的 “C”盘，类型为EXT4日志文件系统，选中逻辑分区和空间起始位置， 因为除了home和usr还有很多别的目录，但那些都不是最重要的，“/”就把除了之前你挂载的home和usr外的全部杂项囊括了，大小也不要太小，最好不低于30GB。如果你非要挨个仔细分配空间，那么你需要知道这些各个分区的含义（Linux(ubuntu)分区挂载点介绍） ，对于 ubuntu18.04 不挂载 "/usr"也可以，会自动挂载在 "/"根目下

                     2、挂载“/home”，类型为EXT4日志文件系统，选中逻辑分区和空间起始位置，这个相当于你的个人文件夹，类似Windows里的User，如果你是个娱乐向的用户，我建议最好能分配稍微大点，因为你的图片、视频、下载内容基本都在这里面，这些东西可不像在Win上面你想移动就能移动的。 

总的来说，最好不要低于50GB ，我Ubuntu分区的总大小是150GB ，这里我给了110GB 给home。

                    3、swap交换空间，这个也就是虚拟内存的地方，选择主分区和空间起始位置。如果你给Ubuntu系统分区容量足够的话，最好是能给到你物理内存的2倍大小，像我8GB内存，就可以给个16GB的空间给它，这个看个人使用情况，太小也不好，太大也没用。（其实我只给了8GB，没什么问题），其实也可以不设置，如果内存足够大，没必要设置，就 ubuntu18.04而言，这个swap 完全可以不要

                    4、boot 一定记住，不要单独/boot划分区;是的不要，不然就完蛋了，结果就是只能进一个系统，因为这里是EFI引导替代boot的grub;也请放心efi分区不会不够用，linux内核不在efi分区而在/boot，在你挂载分区，你会发现也是没有 Boot 的 挂载选项的，新教程这一项不需要了！

      在安装和分区界面，看到最下面一个，安装启动器到，换成你的EFI分区，一般有windows boot manager 等标识，就是 /dev/sda1 EFI 这样的（不分配Boot的具体原因参照此贴：http://forum.ubuntu.org.cn/viewtopic.php?p=3200137）

                  5、挂载“/usr”，类型为EXT4日志文件系统，选中逻辑分区和空间起始位置，这个相当于你的软件安装位置，Linux下一般来说安装第三方软件你是没办法更改安装目录的，系统都会统一地安装到/usr目录下面，因此你就知道了，这个分区必须要大，针对ubuntu18.04也可以不挂在，会在 "/" 根目录下自动挂载一个 "/usr"

（这里特别提醒一下，Ubuntu最新发行版不建议强制获取Root权限，因为我已经玩崩过一次。所以你以后很多文档、图片、包括免安装软件等资源不得不直接放在home分支下面。你作为图形界面用户，只对home分支有完全的读写执行权限，其余分支例如usr你只能在终端使用sudo命令来操作文件，不利于存放一些直接解压使用的免安装软件。因此，建议home分支多分配一点空间……）                

不过就算你把所有目录都自定义分配了空间也必须要给“/”挂载点多分配一定的空间 。          



4、 安装完成 ，重启电脑，默认 Ubuntu 是第一启动项， 重启电脑不能启动 Ubuntu

重启ubuntu18.04卡在某个界面进不去，解决办法如下：

如果启动后报错：BUG soft Lockup,关于这个错误参照下面链接：https://blog.csdn.net/xrinosvip/article/details/80447139 

5、Win10 和Ubuntu 启动引导向管理软件解决办法：https://blog.csdn.net/xrinosvip/article/details/80994450

6、Ubuntu 下使用Linux命令简单总结：https://blog.csdn.net/xrinosvip/article/details/80894728

7、纯英文论文看不懂，翻译软件来帮忙，支持整篇PDF或Word上传，翻译高效准确，首次注册送翻译积分，用于翻译论文：https://www.fanyigou.com/tslg/share/Y19DEA5W.htm

 

Reference：

解决Windows10与Ubuntu16.04双系统时间不一样问题！（亲测，真正的正确方案）

        

            

 

UEFI启动模式和传统的Lagency启动模式完全不同，因此很有必要先了解一下UEFI BIOS和UEFI启动模式

1 必须搞清的几个UEFI问题
(1) UEFI启动模式 与 legacy启动模式
legacy启动模式: 就是这么多年来PC一直在使用的启动方式（从MBR中加载启动程序），UEFI BIOS作为一种新的BIOS自然也应该兼容这种老的启动方式；

UEFI启动模式: UEFI BIOS下新的启动技术。
如果你的PC在UEFI启动模式下预装了Win8，你会发现有两个很小的隐藏分区。一个叫ESP(EFI系统分区)，另一个MSR(Microsoft保留分区，通常为128MB)。MSR是windows要求的。ESP对UEFI启动模式很重要，UEFI的引导程序是以后缀名为.efi的文件存放在ESP分区中的，ESP分区采用fat32文件系统。此外，可能还存在一个小分区叫WinRE
 Tools，这个是win8的恢复分区，体积也很小。所以千万不要手贱把这三个分区删了。但对我们有意义的是ESP分区，windows下想访问ESP分区需用分区工具给它分配盘符并取消隐藏；而ubuntu则直接将这个分区挂载到/boot/efi，直接用文件夹浏览器进去就可以看到各种.efi文件了。

因此第一个关键问题就是确定自己的启动模式，方法是进入BIOS，然后你会发现有一项叫"boot mode"，选中"UEFI boot"就是UEFI启动模式，选中"Legacy boot"就是Legacy启动模式。见过吭爹的UEFI BIOS：有着非常华丽的BIOS界面，还能使用鼠标，但却只支持Legacy boot。

(2) UEFI启动模式只支持64位的系统，所以预装的win8是64位的，ubuntu(kylin)也需要64位的。

(3) UEFI BIOS 和 Legacy BIOS
我们都知道可以在传统的bios中调整设备的启动优先级，UEFI BIOS在UEFI启动模式下不但可以调整设备的优先级，还可以调整设备中引导程序的优先级，安装完ubuntu之后，你再进BIOS就会发现多了一个可选择的启动项叫ubuntu。此外，UEFI BIOS也引入了一些新的技术，例如Fast boot和secure boot，当然后面一项完全是用来坑爹的。

(4) UEFI启动模式下如何从u盘或移动硬盘引导
只要u盘或移动硬盘上有一个fat32的分区，分区的根目录下有个文件夹叫EFI，UEFI就会自动去查找相应的启动文件(.efi)
如果你刚制作了ubuntu(kylin)-13.04-64位的启动u盘，可以打开它，你会发现分区的文件系统是fat32，确实有一个EFI文件夹，进去看看就是各种.efi引导文件（这里再次强调64位，32位下你是找不到这个文件夹的）。因此现在想制作可启动的u盘或移动硬盘就简单了，只需要复制粘贴就行了。
部分UEFI BIOS还支持从NTFS分区中查找启动文件。

最近有小伙伴询问Activity的启动模式是使用singleTask好还是singleTop好，在两种模式中纠结，所以今天就简单讲解一下两种模式的使用场景！

推荐

个人博客：李益的小站
微信公众号：Code满满

Android 的四种启动模式（网上一搜一堆哦）

standard：默认模式，允许多实例
singleTop：相比于standard，有新的启动请求时，只有在目标Activity处于当前栈顶时，才会调用onNewIntent()而不创建新实例，其他情况都和standard一致
singleTask：设置了singleTask启动模式的Activity，它在启动的时候，会先在系统中查找属性值affinity等于它的属性值taskAffinity的任务存在；如果存在这样的任务，它就会在这个任务中启动，否则就会在新任务中启动。因此，如果我们想要设置了singleTask启动模式的Activity在新的任务中启动，就要为它设置一个独立的taskAffinity属性值。如果设置了singleTask启动模式的Activity不是在新的任务中启动时，它会在已有的任务中查看是否已经存在相应的Activity实例，如果存在，就会把位于这个Activity实例上面的Activity全部结束掉，即最终这个Activity实例会位于任务的堆栈顶端中。
singleInstance：和singleTask相比，不同点在于singleInstance activity所在的task只会有这一个activity

Activity的任务栈（Task）简述

Application启动时，系统会为Application创建一个任务栈（Task）
我们对Activity的打开和关闭操作，就是将Activity压入（push）任务栈和从任务栈中弹出（pop）的操作
任务栈遵循先进后出的原则，在栈顶的Activity就是设备当前显示的Activity
singleTask与singleTop一般都是为了保证Activity在任务栈中的唯一性

singleTop的使用
使用singleTop模式的Activity在栈顶时只会在Task中存在一个实例，所以可以在以下场景中使用：

要打开的Activity处于栈顶，点击通知栏打开栈顶的Activity
Activity需要启动一个Service，最后Service对栈顶Activity进行操作
特定情况时，如进行数据刷新，自己跳转自己，走onNewIntent()刷新数据
等等…

总之，singleTop比较适用于childActivity（非主架构Activity，例如MainActivity）
singleTask的使用

当Task中存在Activity实例，不会创建Activity，而是销毁Activity上面所有其他的Activity，以此来使将要跳转的Activity至于栈顶显示，如果不存在，则在栈顶创建一个Activity实例（所以假如有人问如何快速关闭100个Activity，只要给跳转的Activity设置singleTask即可）
单独的使用singleTask,并不会创建一个新的Task
singleTask的Activity如果设置了独立的taskAffinity属性值，启动时就会在新的Task中，否则会在已有Task中

所以基于以上特性，比较适合主架构Activity（例MainActivity）设置为singleTask,或者一些经常使用，但是关闭和跳转不规律的Activity