Android——带你从ADB命令行查看Task任务栈的管理方式

一概念
- 1Task
- 2ActivityStack
- 3ActivityRecordProcessRecord
二任务栈的切换演示
情况一单一Task默认的启动模式下App切换时的Activity栈情况
- 1从App2ActivityB启动App1ActivityA
- 2接着上面我们又从App1ActivityA启动App2ActivityB
情况二单一Task含有SingleTask的模式App切换的Activity栈情况
- 1从ActivityB切换至ActivityA
- 2将MainActivity启动模式变为singleTask这时如果我们从App2ActivityB切换至App1MainActivity会发什么
情况三多TaskSingleTask模式App切换时Activity栈的情况
- 1从App2ActivatyB启动App1ActivityA
- 2从App2ActivityB启动App1MainActivity
三总结

一、概念

1、Task

Task是指将相关的Activity组合到一起，以Activity Stack的方式进行管理。从用户体验上讲，一个“应用程序”就是一个Task(默认情况)，但是从根本上讲，一个Task是可以有一个或多个Android Application组成的。
Task表示一个任务，每一个Task 会有一个ID作为唯一标识。一个进程（程序）有一个默认的task affinity,默认为包名，也可以多个程序指定同一个TaskAffinity。Activity的启动会进入到对应的Task当中或者重新启动一个新的Task。Android源码里面有一个TaskRecord类，该类的一个实例就对应着一个Task。
一组Task以链表的方式相互连接，每一个Task会有一个前驱任务点和后继任务点，以此来管理Task的编辑和查找。ActivityStack外部以链表的形式管理Task，Task内部以后进先出的历史顺序方式管理Activity。
下面的Task的一段源码，我们可以看到它的主要结构：

final class TaskRecord {
    private static final String TAG = TAG_WITH_CLASS_NAME ? "TaskRecord" : TAG_AM;
    ......
    static final String ATTR_TASKID = "task_id";
    ......
    //任务的前驱节点
    TaskRecord mPrevAffiliate; // previous task in affiliated chain.
    int mPrevAffiliateTaskId = INVALID_TASK_ID; // previous id for persistence.
    //该任务的后继节点
    TaskRecord mNextAffiliate; // next task in affiliated chain.
    int mNextAffiliateTaskId = INVALID_TASK_ID; // next id for persistence.
    ......

    /** List of all activities in the task arranged in history order */
    //该Task下的Activity，以后进先出的方式存放
    final ArrayList mActivities;

    /** 当前的Activity栈 */
    ActivityStack stack;
}

2、ActivityStack

Stack表示任务栈，任务栈是以Task为基本单位的。一般我们的程序切换就是Task的切换，一个程序从后台任务栈到前台任务栈，是整个任务栈的移动，而不仅仅是Activity的移动，在任务栈移动之后，再按照LaunchModel的规则对Activity进行操作。与Stack相对应的有Android源码里面的ActivityStack类。一般来说，我们的应用程序都在一个单例的ActivityStack当中。
ActivityStack里面还维护着一个Activity的LRU运行列表，按照最近访问且正在运行的Activity排列。

/**
 * 单列的Activity栈
 * State and management of a single stack of activities.
 */
final class ActivityStack {
    /**
     * List of running activities, sorted by recent usage.
     * The first entry in the list is the least recently used.
     * It contains HistoryRecord objects.
    */
    final ArrayList mLRUActivities = new ArrayList<>();

}

这个是使用adb shell dumpsys activity 查看Activity栈信息的时候打印出来的一个LRU的Activity列表。

 //LRU的方式管理的正在运行的Activity列表
 Running activities (most recent first):
   //#276表示该Task的TaskID;  A = com.example.malingyi.testtask1 表示该Task的TaskAffinity值，sz = 2表示该Task内部Activity的数量
    TaskRecord{51e812a #276 A=com.example.malingyi.testtask1 U=0 sz=2}
     Run #3: ActivityRecord{c5e365e u0 com.example.malingyi.testtask1/.ActivityA t276}
   TaskRecord{56c2a15 #277 A=com.example.malingyi.testtask2 U=0 sz=2}
     Run #2: ActivityRecord{e3bed35 u0 com.example.malingyi.testtask2/.ActivityB t277}
     Run #1: ActivityRecord{532f30e u0 com.example.malingyi.testtask2/.MainActivity t277}
   TaskRecord{51e812a #276 A=com.example.malingyi.testtask1 U=0 sz=2}
     Run #0: ActivityRecord{e5c7c57 u0 com.example.malingyi.testtask1/.MainActivity t276}


 //前台正在运行的Activity
 mResumedActivity: ActivityRecord{3a73c94 u0 com.example.malingyi.testtask2/.ActivityA t253}

3、ActivityRecord、ProcessRecord

ActivityRecord：代表着一个在Task里面正在活动的Acitivty的信息记录。

/**
 * An entry in the history stack, representing an activity.
 */
final class ActivityRecord {
    private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityRecord" : TAG_AM;
    ...

    final ActivityManagerService service; // owner
    final IApplicationToken.Stub appToken; // window manager token
    final ActivityInfo info; // all about me
    final ApplicationInfo appInfo; // information about activity's app
    final int userId;          // Which user is this running for?
    final Intent intent;    // the original intent that generated us
    final ComponentName realActivity;  // the intent component, or target of an alias.
    ...

    //包的名称
    final String packageName; // the package implementing intent's component
    //进程的名称
    final String processName; // process where this component wants to run
    //Task的名称
    final String taskAffinity; // as per ActivityInfo.taskAffinity


    //Activity所在的任务栈
    TaskRecord task;        // the task this is in.
    ...
}

ProcessRecord：当前运行的进程信息，描述了该进程的所有信息。

/**
 * Full information about a particular process that
 * is currently running.
 */
final class ProcessRecord {
    ...
}

二、任务栈的切换演示：

假设：

有两个程序：App1、App2，包名为：App1 = com.example.malingyi.testtask1 App2 = com.example.malingyi.testtask1；
ActivityA属于App1、ActivityB属于App2；两个App都有MainActivity作为启动入口。

情况一：单一Task&默认的启动模式下，App切换时的Activity栈情况

启动模式：

ActivityA：standard
ActivityB：standard
App1、App2：MainActivity：standard

TaskAffinity：

都是默认情况下的TaskAffinity（包名）

初始化启动顺序：

Step1：启动App1：MainActivity——>ActivityA ;
Step2：启动App2：MainActivity——>ActivityB;

**栈顶Activity：**ActivityB

Activity栈：

App1.MainActivity——>App1.ActivityA——>App2.MainActivity——>App2.ActivityB

初始任务栈信息如下：

Stack #8:
    Task id #282 //App2的Task栈
      TaskRecord{cde1503 #282 A=com.example.malingyi.testtask2 U=0 sz=2}  //Task信息
      Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
        Hist #1: ActivityRecord{218b549 u0 com.example.malingyi.testtask2/.ActivityB t282}//Activity信息
          Intent { cmp=com.example.malingyi.testtask2/.ActivityB }
          ProcessRecord{77bd789 3202:com.example.malingyi.testtask2/u0a63}
        Hist #0: ActivityRecord{735919e u0 com.example.malingyi.testtask2/.MainActivity t282}
          Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
          ProcessRecord{77bd789 3202:com.example.malingyi.testtask2/u0a63} //进程信息
    Task id #281。//App1的Task栈
      TaskRecord{8480c80 #281 A=com.example.malingyi.testtask1 U=0 sz=2}  //Task信息
      Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
        Hist #1: ActivityRecord{66d10ee u0 com.example.malingyi.testtask1/.ActivityA t281}//Activity信息
          Intent { cmp=com.example.malingyi.testtask1/.ActivityA }
          ProcessRecord{57c82b9 3305:com.example.malingyi.testtask1/u0a60}
        Hist #0: ActivityRecord{157ed43 u0 com.example.malingyi.testtask1/.MainActivity t281}
          Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
          ProcessRecord{57c82b9 3305:com.example.malingyi.testtask1/u0a60} //进程信息

（1）从App2.ActivityB启动App1.ActivityA

切换后任务栈：

Stack #8:
   Task id #282  //栈顶还是App2的Task，APP.ActivityA进入了App2的Task栈中。
     TaskRecord{cde1503 #282 A=com.example.malingyi.testtask2 U=0 sz=3}
     Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
       Hist #2: ActivityRecord{c6170ac u0 com.example.malingyi.testtask1/.ActivityA t282}
         Intent { act=com.exaple.malingyi.ActivityA cmp=com.example.malingyi.testtask1/.ActivityA }
         ProcessRecord{57c82b9 3305:com.example.malingyi.testtask1/u0a60}
       Hist #1: ActivityRecord{218b549 u0 com.example.malingyi.testtask2/.ActivityB t282}
         Intent { cmp=com.example.malingyi.testtask2/.ActivityB }
         ProcessRecord{77bd789 3202:com.example.malingyi.testtask2/u0a63}
       Hist #0: ActivityRecord{735919e u0 com.example.malingyi.testtask2/.MainActivity t282}
         Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
         ProcessRecord{77bd789 3202:com.example.malingyi.testtask2/u0a63}

   Task id #281
     TaskRecord{8480c80 #281 A=com.example.malingyi.testtask1 U=0 sz=2}
     Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
       Hist #1: ActivityRecord{66d10ee u0 com.example.malingyi.testtask1/.ActivityA t281}
         Intent { cmp=com.example.malingyi.testtask1/.ActivityA }
         ProcessRecord{57c82b9 3305:com.example.malingyi.testtask1/u0a60}
       Hist #0: ActivityRecord{157ed43 u0 com.example.malingyi.testtask1/.MainActivity t281}
         Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
         ProcessRecord{57c82b9 3305:com.example.malingyi.testtask1/u0a60}

初始栈： App1.MainActivity——>App1.ActivityA——>App2.MainActivity——>App2.ActivityB
操作后的栈：App1.MainActivity——>App1.ActivityA——>App2.MainActivity——>App2.ActivityB——>App1.ActivityA

这里我们看到，App1.ActivityA重新创建了一个实例进入了App2的Task栈。

（2）接着上面，我们又从App1.ActivityA启动App2.ActivityB

任务栈信息：

Task id #282   //栈顶仍然是App2的Task，APP2.ActivityB进入了App2的Task栈中。
     TaskRecord{cde1503 #282 A=com.example.malingyi.testtask2 U=0 sz=4}
     Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
       Hist #3: ActivityRecord{6e68c29 u0 com.example.malingyi.testtask2/.ActivityB t282}
         Intent { act=com.exaple.malingyi.ActivityB cmp=com.example.malingyi.testtask2/.ActivityB }
         ProcessRecord{77bd789 3202:com.example.malingyi.testtask2/u0a63}
       Hist #2: ActivityRecord{c6170ac u0 com.example.malingyi.testtask1/.ActivityA t282}
         Intent { act=com.exaple.malingyi.ActivityA cmp=com.example.malingyi.testtask1/.ActivityA }
         ProcessRecord{57c82b9 3305:com.example.malingyi.testtask1/u0a60}
       Hist #1: ActivityRecord{218b549 u0 com.example.malingyi.testtask2/.ActivityB t282}
         Intent { cmp=com.example.malingyi.testtask2/.ActivityB }
         ProcessRecord{77bd789 3202:com.example.malingyi.testtask2/u0a63}
       Hist #0: ActivityRecord{735919e u0 com.example.malingyi.testtask2/.MainActivity t282}
         Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
         ProcessRecord{77bd789 3202:com.example.malingyi.testtask2/u0a63}

   Task id #281
     TaskRecord{8480c80 #281 A=com.example.malingyi.testtask1 U=0 sz=2}
     Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
       Hist #1: ActivityRecord{66d10ee u0 com.example.malingyi.testtask1/.ActivityA t281}
         Intent { cmp=com.example.malingyi.testtask1/.ActivityA }
         ProcessRecord{57c82b9 3305:com.example.malingyi.testtask1/u0a60}
       Hist #0: ActivityRecord{157ed43 u0 com.example.malingyi.testtask1/.MainActivity t281}
         Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
         ProcessRecord{57c82b9 3305:com.example.malingyi.testtask1/u0a60}

初始栈： App1.MainActivity——>App1.ActivityA——>App2.MainActivity——>App2.ActivityB
操作后的栈：App1.MainActivity——>App1.ActivityA——>App2.MainActivity——>App2.ActivityB——>App1.ActivityA——>App2.ActivityB

同样，我们看到新启动的ActivityB，还是在原有的App2的Task栈中。
这里的到了两个结论：

standard模式下，Activity会重新创建一个新的实例，不论原有实例是否存在。
standard模式下，Activity会进入启动它的Activity所在的Task栈中，这个结论对于在启动其他App的Activity也成立。

情况二：单一Task&含有SingleTask的模式，App切换的Activity栈情况

启动模式：

ActivityA：SingleTask
ActivityB：SingleTask
App1、App2：MainActivity：standard

TaskAffinity：

都是默认情况下的TaskAffinity（包名）

初始化启动顺序：

Step1：启动App1：MainActivity——>ActivityA ;
Step2：启动App2：MainActivity——>ActivityB;

栈顶Activity:ActivityB

Activity栈：

App1.MainActivity——>App1.ActivityA——>App2.MainActivity——>App2.ActivityB

初始任务栈：

//所有启动的Activity，按照Task来分组，按照任务的访问顺序从上到下的排列。

Display #0 (activities from top to bottom):
  Stack #7:
    Task id #277   //App2的Task，里面维护了Activity的入栈顺序
      TaskRecord{56c2a15 #277 A=com.example.malingyi.testtask2 U=0 sz=2}
      Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
        Hist #1: ActivityRecord{e3bed35 u0 com.example.malingyi.testtask2/.ActivityB t277}
          Intent { flg=0x10000000 cmp=com.example.malingyi.testtask2/.ActivityB }
          ProcessRecord{9d3fb1b 2959:com.example.malingyi.testtask2/u0a63}
        Hist #0: ActivityRecord{532f30e u0 com.example.malingyi.testtask2/.MainActivity t277}
          Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
          ProcessRecord{9d3fb1b 2959:com.example.malingyi.testtask2/u0a63} //标明Task所属的进程

    Task id #276。 //App1的Task，里面维护了Activity的入栈顺序
      TaskRecord{51e812a #276 A=com.example.malingyi.testtask1 U=0 sz=2}
      Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10000000 cmp=com.example.malingyi.testtask1/.MainActivity }
        Hist #1: ActivityRecord{c5e365e u0 com.example.malingyi.testtask1/.ActivityA t276}
          Intent { flg=0x10000000 cmp=com.example.malingyi.testtask1/.ActivityA }
          ProcessRecord{7a654b8 2877:com.example.malingyi.testtask1/u0a60}
        Hist #0: ActivityRecord{e5c7c57 u0 com.example.malingyi.testtask1/.MainActivity t276}
          Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10000000 cmp=com.example.malingyi.testtask1/.MainActivity }
          ProcessRecord{7a654b8 2877:com.example.malingyi.testtask1/u0a60}  //标明Task所属的进程


    //正在运行的是App2的ActivityB
    mResumedActivity: ActivityRecord{bf1f68 u0 com.example.malingyi.testtask1/com.example.malingyi.testtask2.ActivityB t272}

（1）从ActivityB切换至ActivityA:

切换后任务栈：

Stack #7:
   Task id #276 //App1的整个栈上移了！不止是Activity移到了前面，同时在Task下的MainActivity也一起移动了。
     TaskRecord{51e812a #276 A=com.example.malingyi.testtask1 U=0 sz=2}
     Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10000000 cmp=com.example.malingyi.testtask1/.MainActivity }
       Hist #1: ActivityRecord{c5e365e u0 com.example.malingyi.testtask1/.ActivityA t276}
         Intent { flg=0x10000000 cmp=com.example.malingyi.testtask1/.ActivityA }
         ProcessRecord{7a654b8 2877:com.example.malingyi.testtask1/u0a60}
       Hist #0: ActivityRecord{e5c7c57 u0 com.example.malingyi.testtask1/.MainActivity t276}
         Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10000000 cmp=com.example.malingyi.testtask1/.MainActivity }
         ProcessRecord{7a654b8 2877:com.example.malingyi.testtask1/u0a60}
   Task id #277 //App2的栈下调了
     TaskRecord{56c2a15 #277 A=com.example.malingyi.testtask2 U=0 sz=2}
     Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
       Hist #1: ActivityRecord{e3bed35 u0 com.example.malingyi.testtask2/.ActivityB t277}
         Intent { flg=0x10000000 cmp=com.example.malingyi.testtask2/.ActivityB }
         ProcessRecord{9d3fb1b 2959:com.example.malingyi.testtask2/u0a63}
       Hist #0: ActivityRecord{532f30e u0 com.example.malingyi.testtask2/.MainActivity t277}
         Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
         ProcessRecord{9d3fb1b 2959:com.example.malingyi.testtask2/u0a63}

         初始栈： App1.MainActivity——>App1.ActivityA——>App2.MainActivity——>App2.ActivityB
         操作后的栈：App2.ActivityB——>App1.ActivityA——>App1.MainActivity——>App1.ActivityA

原本只是从ActivityA切换到ActivityB，由于ActivityB是SingleTask同时实例已经存在，那么应该是ActivityB移动到ActivityA之前，但是MainActivity也同时移到了ActivityA之前。MainActivity与ActivityA整个Task栈都移动了。按照Task的定义，ActivityStack栈里是按照Task分组来管理Activity，那么有可能APP之间的切换的调度单位会是Task。

（2）将MainActivity启动模式变为：singleTask。这时如果我们从App2.ActivityB切换至App1.MainActivity会发什么？

切换后任务栈：

Stack #10:
  Task id #289  //App1的Task栈移动到了App2的Task栈之前，但是这时情况是MainActivity之前的App1.ActivityA弹出了。Task栈下只剩MainActivity
    TaskRecord{fd59417 #289 A=com.example.malingyi.testtask1 U=0 sz=1}
    Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
      Hist #0: ActivityRecord{24d5faa u0 com.example.malingyi.testtask1/.MainActivity t289}
        Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
        ProcessRecord{219a9ed 3807:com.example.malingyi.testtask1/u0a60}
  Task id #290
    TaskRecord{1d94004 #290 A=com.example.malingyi.testtask2 U=0 sz=2}
    Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
      Hist #1: ActivityRecord{dd07174 u0 com.example.malingyi.testtask2/.ActivityB t290}
        Intent { flg=0x10000000 cmp=com.example.malingyi.testtask2/.ActivityB }
        ProcessRecord{101c022 3830:com.example.malingyi.testtask2/u0a63}
      Hist #0: ActivityRecord{2c3fdf1 u0 com.example.malingyi.testtask2/.MainActivity t290}
        Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
        ProcessRecord{101c022 3830:com.example.malingyi.testtask2/u0a63}

初始栈： App1.MainActivity——>App1.ActivityA——>App2.MainActivity——>App2.ActivityB
操作后的栈：App2.ActivityB——>App1.ActivityA——>App1.MainActivity

MainActivity为SingleTask之后，由于它已经存在了一个实例，因此切换的时候会把App1的Task移动到App2的Task之前。然后根据SingleTask的规则，会将Task内在它之前的的Activity弹出，使得它置顶。

到了这里，我们可以得出一个结论：

APP切换时，首先，会将切换的App所在的Task移动到最前面；然后，再使用LaunchModel的规则对Activity进行出栈入栈的操作。

然后再作出一个假设：

我们在两个程序之间的切换可能就是Task的切换？

情况三：多Task&SingleTask模式，App切换时Activity栈的情况

启动模式&TaskAffinity：

App1、App2的MainActivity的LaunchModel = SingleTask, TaskAffinity = 包名；
App1中ActivityA: LaunchModel = SingleTask, TaskAffinity = com.TaskA；
App2中ActivityB: LaunchModel = SingleTask, TaskAffinity = com.TaskB；

初始化启动顺序：

Step1：启动App1：MainActivity——>ActivityA ;
Step2：启动App2：MainActivity——>ActivityB;

栈顶Activity:ActivityB

初始Activity栈：

App1.MainActivity——>App1.ActivityA——>App2.MainActivity——>App2.ActivityB

初始任务栈：

//我们可以看到，每一个Activity都在一个Task中，按照他们启动的顺序从上倒下。
  Stack #11:
    Task id #296 //App2.ActivityB的任务栈com.TaskB
      TaskRecord{85070a0 #296 A=com.TaskB U=0 sz=1}
      Intent { flg=0x10000000 cmp=com.example.malingyi.testtask2/.ActivityB }
        Hist #0: ActivityRecord{8c75fd1 u0 com.example.malingyi.testtask2/.ActivityB t296}
          Intent { flg=0x10000000 cmp=com.example.malingyi.testtask2/.ActivityB }
          ProcessRecord{f5bf6cc 4090:com.example.malingyi.testtask2/u0a63}

    Task id #295 //App2.MainActivity的任务栈com.example.malingyi.testtask2
      TaskRecord{850e459 #295 A=com.example.malingyi.testtask2 U=0 sz=1}
      Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
        Hist #0: ActivityRecord{52f95ba u0 com.example.malingyi.testtask2/.MainActivity t295}
          Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
          ProcessRecord{f5bf6cc 4090:com.example.malingyi.testtask2/u0a63}
    Task id #294  //App1.ActivityA的任务栈
      TaskRecord{5da881e #294 A=com.TaskA U=0 sz=1}
      Intent { flg=0x10000000 cmp=com.example.malingyi.testtask1/.ActivityA }
        Hist #0: ActivityRecord{43ed667 u0 com.example.malingyi.testtask1/.ActivityA t294}
          Intent { flg=0x10000000 cmp=com.example.malingyi.testtask1/.ActivityA }
          ProcessRecord{d226d15 4068:com.example.malingyi.testtask1/u0a60}
    Task id #293   //App1.MainActivity的任务栈
      TaskRecord{8b948ff #293 A=com.example.malingyi.testtask1 U=0 sz=1}
      Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
        Hist #0: ActivityRecord{7669776 u0 com.example.malingyi.testtask1/.MainActivity t293}
          Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
          ProcessRecord{d226d15 4068:com.example.malingyi.testtask1/u0a60}

    //正在最前台的Activity
    mResumedActivity: ActivityRecord{8c75fd1 u0 com.example.malingyi.testtask2/.ActivityB t296}

从上面的结果可以看出，由于给ActivityA、ActivityB指定了TaskAffinity、SingleTask，两个MainActivity跟随App默认的任务栈，因此每一个Activity都有一个Task任务栈。但还是会按照进程将他们分为两个APP。

注意看ProcessRecord字段会发现，App1.ActivityA和App1.MainActivity1是属于同一个Process(d226d15 4068:com.example.malingyi.testtask1/u0a60)。而App2.ActivityB和App2.MainActivity2是属于另一个
Process(f5bf6cc 4090:com.example.malingyi.testtask2/u0a6)。

（1）从App2.ActivatyB启动App1.ActivityA

切换任务栈：

Stack #11:
    Task id #294 //App1.ActivityA所在的任务栈移到了最前面
      TaskRecord{5da881e #294 A=com.TaskA U=0 sz=1}
      Intent { flg=0x10000000 cmp=com.example.malingyi.testtask1/.ActivityA }
        Hist #0: ActivityRecord{43ed667 u0 com.example.malingyi.testtask1/.ActivityA t294}
          Intent { flg=0x10000000 cmp=com.example.malingyi.testtask1/.ActivityA }
          ProcessRecord{d226d15 4068:com.example.malingyi.testtask1/u0a60}
    Task id #296 //App2.ActivityB所在的任务栈
      TaskRecord{85070a0 #296 A=com.TaskB U=0 sz=1}
      Intent { flg=0x10000000 cmp=com.example.malingyi.testtask2/.ActivityB }
        Hist #0: ActivityRecord{8c75fd1 u0 com.example.malingyi.testtask2/.ActivityB t296}
          Intent { flg=0x10000000 cmp=com.example.malingyi.testtask2/.ActivityB }
          ProcessRecord{f5bf6cc 4090:com.example.malingyi.testtask2/u0a63}
    Task id #295 //App2.MainActivity所在的任务栈
      TaskRecord{850e459 #295 A=com.example.malingyi.testtask2 U=0 sz=1}
      Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
        Hist #0: ActivityRecord{52f95ba u0 com.example.malingyi.testtask2/.MainActivity t295}
          Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
          ProcessRecord{f5bf6cc 4090:com.example.malingyi.testtask2/u0a63}
    Task id #293 //App1.MainActivity所在的任务栈
      TaskRecord{8b948ff #293 A=com.example.malingyi.testtask1 U=0 sz=1}
      Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
        Hist #0: ActivityRecord{7669776 u0 com.example.malingyi.testtask1/.MainActivity t293}
          Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
          ProcessRecord{d226d15 4068:com.example.malingyi.testtask1/u0a60}

    Running activities (most recent first):
      TaskRecord{5da881e #294 A=com.TaskA U=0 sz=1}
        Run #3: ActivityRecord{43ed667 u0 com.example.malingyi.testtask1/.ActivityA t294}
      TaskRecord{85070a0 #296 A=com.TaskB U=0 sz=1}
        Run #2: ActivityRecord{8c75fd1 u0 com.example.malingyi.testtask2/.ActivityB t296}
      TaskRecord{850e459 #295 A=com.example.malingyi.testtask2 U=0 sz=1}
        Run #1: ActivityRecord{52f95ba u0 com.example.malingyi.testtask2/.MainActivity t295}
      TaskRecord{8b948ff #293 A=com.example.malingyi.testtask1 U=0 sz=1}
        Run #0: ActivityRecord{7669776 u0 com.example.malingyi.testtask1/.MainActivity t293}

    mResumedActivity: ActivityRecord{43ed667 u0 com.example.malingyi.testtask1/.ActivityA t294}

这里我们看到，只有Task#294(App1.ActivityA)移动到了Task#296(App2.ActivityB)之前，App1.MainActivity所在的Task#293，并没有移动。

初始栈： App1.MainActivity——>App1.ActivityA——>App2.MainActivity——>App2.ActivityB
操作后的栈：App1.MainActivity——>App2.MainActivity——>App2.ActivityB——>App1.ActivityA

（2）从App2.ActivityB启动App1.MainActivity

切换任务栈：

Stack #12:
   Task id #297  //App1.MainActivity所在的任务栈移到了最前面
     TaskRecord{6b63e70 #297 A=com.example.malingyi.testtask1 U=0 sz=1}
     Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
       Hist #0: ActivityRecord{f87eb51 u0 com.example.malingyi.testtask1/.MainActivity t297}
         Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask1/.MainActivity bnds=[60,972][180,1092] (has extras) }
         ProcessRecord{818d19c 4795:com.example.malingyi.testtask1/u0a60}
   Task id #300  //App2.ActivityB所在的任务栈
     TaskRecord{d3ee5e9 #300 A=com.TaskB U=0 sz=1}
     Intent { flg=0x10000000 cmp=com.example.malingyi.testtask2/.ActivityB }
       Hist #0: ActivityRecord{3df6276 u0 com.example.malingyi.testtask2/.ActivityB t300}
         Intent { flg=0x10000000 cmp=com.example.malingyi.testtask2/.ActivityB }
         ProcessRecord{d16f7a5 4819:com.example.malingyi.testtask2/u0a63}
   Task id #299  //App2.MainActivity所在的任务栈
     TaskRecord{90b126e #299 A=com.example.malingyi.testtask2 U=0 sz=1}
     Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
       Hist #0: ActivityRecord{9778bab u0 com.example.malingyi.testtask2/.MainActivity t299}
         Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=com.example.malingyi.testtask2/.MainActivity bnds=[236,972][356,1092] (has extras) }
         ProcessRecord{d16f7a5 4819:com.example.malingyi.testtask2/u0a63}
   Task id #298  //App1.ActivityA所在的任务栈
     TaskRecord{8688d0f #298 A=com.TaskA U=0 sz=1}
     Intent { flg=0x10000000 cmp=com.example.malingyi.testtask1/.ActivityA }
       Hist #0: ActivityRecord{f78be54 u0 com.example.malingyi.testtask1/.ActivityA t298}
         Intent { flg=0x10000000 cmp=com.example.malingyi.testtask1/.ActivityA }
         ProcessRecord{818d19c 4795:com.example.malingyi.testtask1/u0a60}

我重新启动了一次APP，因此Task#ID改变了，但是他们初始的启动顺序没变。

初始栈： App1.MainActivity——>App1.ActivityA——>App2.MainActivity——>App2.ActivityB。
操作后的栈：App1.ActivityA——>App2.MainActivity——>App2.ActivityB——>App1.MainActivity

我们仍然看到，只有Task#297 (App1.MainActivity)移动到了Task#300(App2.ActivityB)之前，App1.ActivityA所在的Task#298。

到了这里，假设已经得到了实践的验证：

Android的APP切换，实际上是Activity以Task为单位来进行切换，将被选中的Activity所在的Task移动到Stack任务栈的最前端，然后在Task内部使用LaunchModel规则对Task内部的Activity进行操作。

三、总结

standard模式下，Activity会进入启动它的Activity所在的Task栈中，这个结论对于在启动其他App的Activity也成立。
LaunchModel的启动规则，在跨App之间时启动Activity同样成立。
在APP之间切换时。首先，会将切换的App所在的Task移动到最前面；然后，再使用LaunchModel的规则对Activity进行出栈入栈的操作。
Android的APP切换，实际上是以Task为单位来进行切换，将被选中的Activity所在的Task移动到Stack任务栈的最前端，然后在Task内部根据Activity的启动模式，使用LaunchModel规则对Task内部的Activity进行操作。

你可能感兴趣的:(Android,Coding,编程体会,Android开发)

android系统selinux中添加新属性property 辉色投像
1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
Git常用命令－修改远程仓库地址猿大师 Linux Java git java
查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redis bootstrap 数据库
1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
2.2.6 通知类控件 Toast、Menu 常思行
本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
用Python实现读取统计单词个数程序媛了了 python 游戏 java
完整实例代码：fromcollectionsimportCounterdefpythonit():danci={}withopen("pythonit.txt","r",encoding="utf-8")asf:foriinf:words=i.strip().split()forwordinwords:ifwordnotindanci:danci[word]=1else:danci[word]+=
mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac 备份android 手机通讯录导入iphone
在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android 更改窗口的层次
最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
Android应用性能优化轻口味 Android
Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
Android实现监听事件的方法 Amy木婉清
1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
（1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
kt文件和java文件_Java与Kotlin之间怎样进行互操作铭空间 kt文件和java文件
Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
Android shell 常用 debug 命令晨春计 Audio debug android linux
目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员 android 面试学习
总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据 python hadoop 计算机毕业设计选题计算机毕业设计源码数据分析 spark毕设
作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
android ndk 开发jni调用对象方法，数组参数 wulongkou 开发问题安卓的事 ndk android studio jni
一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
Android jni中数组参数的传递方式 lokeyme Andriod android开发 JNI NDK java c语言
1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
使用ffmpeg将pcm格式音频转化为mp3格式音频布丁小站 ffmpeg pcm 音视频
voidAudioCode::ENcode(AVCodecContext*cdc_ctx,AVFrame*frame,AVPacket*pkt){intret=0;/*sendtheframeforencoding*/ret=avcodec_send_frame(cdc_ctx,frame);if(ret=0){ret=avcodec_receive_packet(cdc_ctx,pkt);if(
1-1.Jetpack 之 Navigation 简单编码模板我命由我12345 Android -Jetpack 简化编程 java java-ee android-studio android studio 安卓 android jetpack
一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
python+adb 0o一人情 adb命令 Python项目 python 开发语言
#!/usr/bin/pythonenv#-*-coding:utf-8-*-importosimportsysimportsubprocessfromtimeimportsleepimportlogginglogging.basicConfig(level=logging.DEBUG)classScreenCapture():defget_screen_size(self):"""获取手机分辨率
opencv 学习 1 木木ainiks opencv 计算机视觉 python
opencv学习的第一天#coding:utf-8importcv2ascv#首先读图片src=cv.imread(“img/1.jpg”)#设置图片的名字cv.namedWindow(“1”,cv.WINDOW_AUTOSIZE)#显示图片第一个参数设置图片名，第二个参数图片的地址cv.imshow(“1”,src)cv.waitKey(0)#将图片写入固定位置cv.imwrite(“img/2
Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用 erhtre 程序员 android jetpack 架构 sqlite
为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
Android干净架构MVI模板使用指南井美婵Toby
Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
⭐Unity 安卓环境中正确地读取和处理 XML 文件惊鸿醉 Unity unity android xml
写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
《Android进阶之光》读书笔记 soleil雪寂读书笔记 #Android进阶之光
文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
《Android进阶之光》— Android 书籍王睿丶 Android 永无止境《Android进阶之光》Android书籍 Android phoenix 移动开发
文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
《android进阶之光》——多线程编程（上） TAING要一直努力读书笔记
今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
android进阶之光！Android面试必备的集合源码详解，系列篇程序员Sunbu 程序员 Android
前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
Android-悬浮窗功能的实现（附Java、KT实现源码）(1) egrhef 程序员 android java 开发语言
//获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
Visual Studio中的Android模拟器使用详解 wurui8 android android studio android android应用
关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
异常的核心类Throwable 无量 java 源码异常处理 exception
java异常的核心是Throwable，其他的如Error和Exception都是继承的这个类里面有个核心参数是detailMessage，记录异常信息，getMessage核心方法，获取这个参数的值，我们可以自己定义自己的异常类，去继承这个Exception就可以了，方法基本上，用父类的构造方法就OK，所以这么看异常是不是很easy package com.natsu;
mongoDB 游标（cursor）实现分页迭代开窍的石头 mongodb
上篇中我们讲了mongoDB 中的查询函数，现在我们讲mongo中如何做分页查询如何声明一个游标 var mycursor = db.user.find({_id:{$lte:5}}); 迭代显示游标数
MySQL数据库INNODB 表损坏修复处理过程 0624chenhong tomcat mysql
最近mysql数据库经常死掉，用命令net stop mysql命令也无法停掉，关闭Tomcat的时候，出现Waiting for N instance(s) to be deallocated 信息。查了下，大概就是程序没有对数据库连接释放，导致Connection泄露了。因为用的是开元集成的平台，内部程序也不可能一下子给改掉的，就验证一下咯。启动Tomcat,用户登录系统，用netstat -
剖析如何与设计人员沟通不懂事的小屁孩工作
最近做图烦死了，不停的改图，改图……。烦，倒不是因为改，而是反反复复的改，人都会死。很多需求人员不知该如何与设计人员沟通，不明白如何使设计人员知道他所要的效果，结果只能是沟通变成了扯淡，改图变成了应付。那应该如何与设计人员沟通呢？我认为设计人员与需求人员先天就存在语言障碍。对一个合格的设计人员来说，整天玩的都是点、线、面、配色，哪种构图看起来协调；哪种配色看起来合理心里跟明镜似的，
qq空间刷评论工具换个号韩国红果果 JavaScript
var a=document.getElementsByClassName('textinput'); var b=[]; for(var m=0;m<a.length;m++){ if(a[m].getAttribute('placeholder')!=null) b.push(a[m]) } var l
S2SH整合之session 灵静志远 spring AOP struts session
错误信息： Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'cartService': Scope 'session' is not active for the current thread; consider defining a scoped
xmp标签 a-john 标签
今天在处理数据的显示上遇到一个问题： var html = '<li><div class="pl-nr"><span class="user-name">' + user + '</span>' + text + '</div></li>'; ulComme
Ajax的常用技巧（2）---实现Web页面中的级联菜单 aijuans Ajax
在网络上显示数据，往往只显示数据中的一部分信息，如文章标题，产品名称等。如果浏览器要查看所有信息，只需点击相关链接即可。在web技术中，可以采用级联菜单完成上述操作。根据用户的选择，动态展开，并显示出对应选项子菜单的内容。在传统的web实现方式中，一般是在页面初始化时动态获取到服务端数据库中对应的所有子菜单中的信息，放置到页面中对应的位置，然后再结合CSS层叠样式表动态控制对应子菜单的显示或者隐
天-安-门，好高 atongyeye 情感
我是85后，北漂一族，之前房租1100，因为租房合同到期，再续，房租就要涨150。最近网上新闻，地铁也要涨价。算了一下，涨价之后，每次坐地铁由原来2块变成6块。仅坐地铁费用，一个月就要涨200。内心苦痛。晚上躺在床上一个人想了很久，很久。我生在农
android 动画百合不是茶 android 透明度平移缩放旋转
android的动画有两种 tween动画和Frame动画 tween动画;,透明度,缩放,旋转,平移效果 Animation 动画 AlphaAnimation 渐变透明度 RotateAnimation 画面旋转 ScaleAnimation 渐变尺寸缩放 TranslateAnimation 位置移动 Animation
查看本机网络信息的cmd脚本 bijian1013 cmd
@echo 您的用户名是：%USERDOMAIN%\%username%>"%userprofile%\网络参数.txt" @echo 您的机器名是：%COMPUTERNAME%>>"%userprofile%\网络参数.txt" @echo ___________________>>"%userprofile%\
plsql 清除登录过的用户征客丶 plsql
tools---preferences----logon history---history 把你想要删除的删除 -------------------------------------------------------------------- 若有其他凝问或文中有错误，请及时向我指出，我好及时改正，同时也让我们一起进步。 email ： binary_spac
【Pig一】Pig入门 bit1129 pig
Pig安装 1.下载pig wget http://mirror.bit.edu.cn/apache/pig/pig-0.14.0/pig-0.14.0.tar.gz 2. 解压配置环境变量如果Pig使用Map/Reduce模式，那么需要在环境变量中，配置HADOOP_HOME环境变量 expor
Java 线程同步几种方式 BlueSkator volatile synchronized ThredLocal ReenTranLock Concurrent
为何要使用同步？ java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。 1.同步方法&
StringUtils判断字符串是否为空的方法（转帖） BreakingBad null StringUtils “”
转帖地址：http://www.cnblogs.com/shangxiaofei/p/4313111.html public static boolean isEmpty(String str) 　　判断某字符串是否为空，为空的标准是 str== null 或 str.length()== 0
编程之美-分层遍历二叉树 bylijinnan java 数据结构算法编程之美
import java.util.ArrayList; import java.util.LinkedList; import java.util.List; public class LevelTraverseBinaryTree { /** * 编程之美分层遍历二叉树 * 之前已经用队列实现过二叉树的层次遍历，但这次要求输出换行，因此要
jquery取值和ajax提交复习记录 chengxuyuancsdn jquery取值 ajax提交
// 取值 // alert($("input[name='username']").val()); // alert($("input[name='password']").val()); // alert($("input[name='sex']:checked").val()); // alert($("
推荐国产工作流引擎嵌入式公式语法解析器-IK Expression comsci java 应用服务器工作 Excel 嵌入式
这个开源软件包是国内的一位高手自行研制开发的，正如他所说的一样，我觉得它可以使一个工作流引擎上一个台阶。。。。。。欢迎大家使用，并提出意见和建议。。。 ----------转帖--------------------------------------------------- IK Expression是一个开源的（OpenSource），可扩展的（Extensible），基于java语言
关于系统中使用多个PropertyPlaceholderConfigurer的配置及PropertyOverrideConfigurer daizj spring
1、PropertyPlaceholderConfigurer Spring中PropertyPlaceholderConfigurer这个类，它是用来解析Java Properties属性文件值，并提供在spring配置期间替换使用属性值。接下来让我们逐渐的深入其配置。基本的使用方法是：(1) <bean id="propertyConfigurerForWZ&q
二叉树:二叉搜索树 dieslrae 二叉树
所谓二叉树,就是一个节点最多只能有两个子节点,而二叉搜索树就是一个经典并简单的二叉树.规则是一个节点的左子节点一定比自己小,右子节点一定大于等于自己(当然也可以反过来).在树基本平衡的时候插入,搜索和删除速度都很快,时间复杂度为O(logN).但是,如果插入的是有序的数据,那效率就会变成O(N),在这个时候,树其实变成了一个链表. tree代码:
C语言字符串函数大全 dcj3sjt126com c function
C语言字符串函数大全函数名: stpcpy 功能: 拷贝一个字符串到另一个用法: char *stpcpy(char *destin, char *source); 程序例: #include <stdio.h> #include <string.h> int main
友盟统计页面技巧 dcj3sjt126com 技巧
在基类调用就可以了, 基类ViewController示例代码 -(void)viewWillAppear:(BOOL)animated { [super viewWillAppear:animated]; [MobClick beginLogPageView:[NSString stringWithFormat:@"%@",self.class]];
window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法 flyvszhb java jdk
window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法本机已经安装了jdk1.7，而比较早期的项目需要依赖jdk1.6，于是同时在本机安装了jdk1.6和jdk1.7. 安装jdk1.6前，执行java -version得到 C:\Users\liuxiang2>java -version java version "1.7.0_21&quo
Java在创建子类对象的同时会不会创建父类对象 happyqing java 创建子类对象父类对象
1.在thingking in java 的第四版第六章中明确的说了，子类对象中封装了父类对象， 2."When you create an object of the derived class, it contains within it a subobject of the base class. This subobject is the sam
跟我学spring3 目录贴及电子书下载 jinnianshilongnian spring
一、《跟我学spring3》电子书下载地址：《跟我学spring3》（1-7 和 8-13） http://jinnianshilongnian.iteye.com/blog/pdf 跟我学spring3系列 word原版下载二、源代码下载最新依
第12章 Ajax（上） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
BI and EIM 4.0 at a glance blueoxygen BO
http://www.sap.com/corporate-en/press.epx?PressID=14787 有机会研究下EIM家族的两个新产品~~~~ New features of the 4.0 releases of BI and EIM solutions include: Real-time in-memory computing –
Java线程中yield与join方法的区别 tomcat_oracle java
长期以来，多线程问题颇为受到面试官的青睐。虽然我个人认为我们当中很少有人能真正获得机会开发复杂的多线程应用(在过去的七年中，我得到了一个机会)，但是理解多线程对增加你的信心很有用。之前，我讨论了一个wait()和sleep()方法区别的问题，这一次，我将会讨论join()和yield()方法的区别。坦白的说，实际上我并没有用过其中任何一个方法，所以，如果你感觉有不恰当的地方，请提出讨论。 &nb
android Manifest.xml选项阿尔萨斯 Manifest
结构继承关系 public final class Manifest extends Objectjava.lang.Objectandroid.Manifest 内部类 class Manifest.permission权限 class Manifest.permission_group权限组构造函数 public Manifest () 详细 androi
Oracle实现类split函数的方 zhaoshijie oracle
关键字：Oracle实现类split函数的方项目里需要保存结构数据，批量传到后他进行保存，为了减小数据量，子集拼装的格式，使用存储过程进行保存。保存的过程中需要对数据解析。但是oracle没有Java中split类似的函数。从网上找了一个，也补全了一下。 CREATE OR REPLACE TYPE t_split_100 IS TABLE OF VARCHAR2(100); cr