Android进程prcess生命周期等级、活动Activity生命周期

最新推荐文章于 2022-09-28 16:44:13 发布

Leemboy

最新推荐文章于 2022-09-28 16:44:13 发布

阅读量407

点赞数

Android进程5个等级和生命周期

Android进程有5个等级，详细内容如下：

　　1、前台进程（Foreground process）：
　　用户当前工作需要。一个进程如果满足下列任何条件被认为是前台进程：

　　1.1 正运行着一个正在与用户交互的活动（Activity对象的onResume()方法已经被调用）。
　　1.2 寄宿了一个服务，该服务与一个与用户交互的活动绑定。
　　1.3 有一个Service对象执行它的生命周期回调（onCreate()、onStart()、onDestroy()）。
　　1.4 有一个BroadcastReceiver对象执行他的onReceive()方法。

　　在给定时间内仅有少数的前台进程存在。仅作为最后采取的措施他们才会被杀掉——如果内存太低以至于他们不能继续运行。

　　2、可视进程(Visible process)：
　　没有任何前台组件，但是仍然能影响用户在屏幕上看到东西。一个进程满足下面任何一个条件都被认为是可视的：

　　2.1 寄宿着一个不是前台的活动，但是它对用户仍可见（它的onPause()方法已经被调用）。举例来说，这可能发生在，如果一个前台活动在一个对话框（其他进程的）运行之后仍然是可视的，比如输入法的弹出时。
　　2.2 寄宿着一个服务，该服务绑定到一个可视的活动。

　　一个可视进程被认为是及其重要的且不会被杀死，除非为了保持前台进程运行。

　　3、服务进程(Service process)：

是一个运行着一个用startService()方法启动的服务，并且该服务并没有落入上面2种分类。虽然服务进程没有直接关系到任何用户可见的，它们通常做用户关心的事（诸如在后台播放mp3或者从网络上下载数据），因此系统保持它们运行，除非没有足够内存来保证所有的前台进程和可视进程。

　　4、后台进程(Background process)：

是一个保持着一个当前对用户不可视的活动（已经调用Activity对象的onStop()方法）（如果还有除了UI线程外其他线程在运行话，不受影响）。这些进程没有直接影响用户体验，并且可以在任何时候被杀以收回内存用于一个前台、可视、服务进程。一般地有很多后台进程运行着，因此它们保持在一个LRU（least recently used，即最近最少使用，如果您学过操作系统的话会觉得它很熟悉，跟内存的页面置换算法LRU一样。）列表以确保最近使用最多的活动的进程最后被杀。

　　5、空进程(Empty process)：

是一个没有保持活跃的应用程序组件的进程。保持这个进程可用的唯一原因是作为一个cache以提高下次启动组件的速度。系统进程杀死这些进程，以在进程cache和潜在的内核cache之间平衡整个系统资源。

　　一个进程的排名因为其他进程依赖它而上升。一个进程服务其它进程，它的排名从不会比它服务的进程低。例如，进程A中的一个内容提供者服务进程B中的一个客户，或者进程A中的一个服务绑定到进程B中的一个组件，进程A总是被认为比进程B重要。

　　因为一个服务进程排名比后台活动的进程排名高，一个活动启动一个服务来初始化一个长时间运行操作，而不是简单地衍生一个线程——特别是如果操作很可能会拖垮活动（例如出现ANR）。这方面的例子是在后台播放音乐和上传相机拍摄的图片到一个网站。使用服务保证操作至少有“服务进程”的优先级，无论活动发生什么情况。

Activity和生命周期

1、 Activity生命周期

Activity生命周期是指Activity从启动到销毁的过程

Activity表现为四种状态。

1.1 活动状态：Activity在用户界面中处于最上层，完全能被用户看到，能够与用户进行交互

1.2 暂停状态：Activity界面上被部分遮挡，该Activity不再处于用户界面的最上层，且不能够与用户进行交互

1.3 停止状态：Activity在界面上完全不能被用户看到，也就是说这个Activity被其他Activity全部遮挡

1.4 非活动状态：不在这三种状态中的Activity则处于非活动状态。

2.1  四种状态变换关系

许多生命周期的分析都是纸上谈兵，没有经过实际项目的验证，光看些官方文档时不够的，对其的理解也是也不全面不深刻的。

activity是单独的，用于处理用户操作。几乎所有的activity都要和用户打交道，所以activity类创建了一个窗口，开发人员可以通过setContentView(View)接口把UI放到activity创建的窗口上，当 activity指向全屏窗口时，也可以用其他方式实现：作为漂浮窗口（通过windowIsFloating的主题集合），或者嵌入到其他的 activity（使用ActivityGroup）。大部分的Activity子类都需要实现以下两个接口：

onCreate(Bundle)接口是初始化activity的地方. 在这儿通常可以调用setContentView(int)设置在资源文件中定义的UI, 使用findViewById(int) 可以获得UI中定义的窗口.
onPause()接口是使用者准备离开activity的地方，在这儿，任何的修改都应该被提交(通常用于ContentProvider保存数据).
为了能够使用Context.startActivity()，所有的activity类都必须在AndroidManifest.xml文件中定义有相关的“activity”项。

activity类是Android 应用生命周期的重要部分。

Activity生命周期

在系统中的Activity被一个Activity栈所管理。当一个新的Activity启动时，将被放置到栈顶，成为运行中的Activity，前一个Activity保留在栈中，不再放到前台，直到新的Activity退出为止。

Activity有四种本质区别的状态：

在屏幕的前台（Activity栈顶），叫做活动状态或者运行状态（active or running）
如果一个Activity失去焦点，但是依然可见（一个新的非全屏的Activity 或者一个透明的Activity 被放置在栈顶），叫做暂停状态（Paused）。一个暂停状态的Activity依然保持活力（保持所有的状态，成员信息，和窗口管理器保持连接），但是在系统内存极端低下的时候将被杀掉。
如果一个Activity被另外的Activity完全覆盖掉，叫做停止状态（Stopped）。它依然保持所有状态和成员信息，但是它不再可见，所以它的窗口被隐藏，当系统内存需要被用在其他地方的时候，Stopped的Activity将被杀掉。
如果一个Activity是Paused或者Stopped状态，系统可以将该Activity从内存中删除，Android系统采用两种方式进行删除，要么要求该Activity结束，要么直接杀掉它的进程。当该Activity再次显示给用户时，它必须重新开始和重置前面的状态。
下面的图显示了Activity的重要状态转换，矩形框表明Activity在状态转换之间的回调接口，开发人员可以重载实现以便执行相关代码，带有颜色的椭圆形表明Activity所处的状态。

Activity 生命周期, lifecycle

在上图中，Activity有三个关键的循环：

整个的生命周期，从onCreate(Bundle)开始到onDestroy()结束。Activity在onCreate()设置所有的“全局”状态，在onDestory()释放所有的资源。例如：某个Activity有一个在后台运行的线程，用于从网络下载数据，则该Activity可以在onCreate()中创建线程,在onDestory()中停止线程。
可见的生命周期，从onStart()开始到onStop()结束。在这段时间，可以看到Activity在屏幕上，尽管有可能不在前台，不能和用户交互。在这两个接口之间，需要保持显示给用户的UI数据和资源等，例如：可以在onStart中注册一个IntentReceiver来监听数据变化导致UI的变动，当不再需要显示时候，可以在onStop()中注销它。onStart()，onStop()都可以被多次调用，因为Activity随时可以在可见和隐藏之间转换。
前台的生命周期，从onResume()开始到onPause()结束。在这段时间里，该Activity处于所有 Activity的最前面，和用户进行交互。Activity可以经常性地在resumed和paused状态之间切换，例如：当设备准备休眠时，当一个 Activity处理结果被分发时，当一个新的Intent被分发时。所以在这些接口方法中的代码应该属于非常轻量级的。
Activity的整个生命周期都定义在下面的接口方法中，所有方法都可以被重载。所有的Activity都需要实现 onCreate(Bundle)去初始化设置，大部分Activity需要实现onPause()去提交更改过的数据，当前大部分的Activity也需要实现onFreeze()接口，以便恢复在onCreate(Bundle)里面设置的状态。

public class Activity extends ApplicationContext {

protected void onCreate(Bundle icicle);

protected void onStart();

protected void onRestart();

protected void onResume();

protected void onFreeze(Bundle outIcicle);

protected void onPause();

protected void onStop();

protected void onDestroy();}

2.3 Activity栈

先进先出规则

2.4 事件回调函数

2.5 Activity状态保存/恢复的事件回调函数

2.6 事件回调函数的调用顺序

                                                                                                                图1

从图中可以看到有几个函数被调用。

1、 onCreate    -- Activity创建的时候被调用

2、 onStart       -- Activity可见的时候被调用

3、 onResume --Activity恢复时被调用

4、 onPause     --Activity局部可见的时候被调用

5、 onStop        -- Activity停止即Activity不可见但并没有被销毁时调用

6、 onRestart    -- Activity从停止状态返回到可见状态时被调用

7、 onDestory   -- Activity被销毁的时候被调用

为了能够比较直观看到这些函数是在什么时候被调用的。我们建立一个ActivityLifeCycle的工程，具体来操作一下。

[java] view plain copy

public class ActivityLife extends Activity {

    final String TAG = "ActivityLife";
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_activity_life);
    //打印当前调用的函数
            Log.i(TAG, "it's the time calling onCreate");
    }
    @Override
    protected void onStart() {
        // TODO Auto-generated method stub
        super.onStart();
    //打印当前调用的函数
        Log.i(TAG, "it's the time calling onStart");
    }
    @Override
    protected void onRestart() {
        // TODO Auto-generated method stub
        super.onRestart();
    //打印当前调用的函数
        Log.i(TAG, "it's the time calling onRestart");
    }

    @Override
    protected void onResume() {
        // TODO Auto-generated method stub
        super.onResume();
    //打印当前调用的函数
        Log.i(TAG, "it's the time calling onResume");
    }
    @Override
    protected void onPause() {
        // TODO Auto-generated method stub
        super.onPause();
    //打印当前调用的函数
        Log.i(TAG, "it's the time calling onPause");
    }
    @Override
    protected void onStop() {
        // TODO Auto-generated method stub
        super.onStop();
    //打印当前调用的函数
        Log.i(TAG, "it's the time calling onStop");
    }
    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
    //打印当前调用的函数
        Log.i(TAG, "it's the time calling onDestroy");
    }
}

    程序在回调函数里面我们都会打印当前调用的函数是什么。我们就从具体的几个场景来试验一下，这些函数被调用的顺序。

场景一、启动Activit

Logcat打印出来的是：

可以看到，调用次序是onCreate->onStart->onResume

场景二、按返回键退出Activity

Logcat打印出来的是：

可以看到，调用次序是onPause->onStop->onDestroy

场景三、按Home键返回主屏幕

Logcat打印出来的是：

可以看到，调用次序是onPause->onStop

场景四、退回主屏幕之后，再从新启动Activity

Logcat打印出来的是：

可以看到，调用次序是onRestart->onStart->onResume

根据图1和我们做的实验，我们来总结一下这个生命周期。

第一这个onCreate()是在程序第一次创建的时候调用的。当然也包括这个Activity被销毁之后（调用onDestroy()）再创建的时候也会被调用。

第二  我们需要注意的是，生命周期中的回调函数，像是一个链表中的结点，他们是有顺序的，不会从一个结点直接跳到不相邻的结点，不会从onCreate()直接跳到onResume()，而是从onCreate()找到下一个结点onStart()再找到onResume()。

第三按下Home键，虽然Activity看不见了，但是它并没有调用onDestroy(),也就是说这个Activity并没有被销毁，只是处于停止的状态。

第四当我们需要处理一些如果应用程序不可见的时候就释放某些资源的时候，比如预览摄像头等，尽量用onPause()和onResum()这两个回掉函数，因为这两个函数一定会被调用，其他不一定被调用。

图1

从图中可以看到有几个函数被调用。

1、 onCreate -- Activity创建的时候被调用

2、 onStart -- Activity可见的时候被调用

3、 onResume --Activity恢复时被调用

4、 onPause --Activity局部可见的时候被调用

5、 onStop -- Activity停止即Activity不可见但并没有被销毁时调用

6、 onRestart -- Activity从停止状态返回到可见状态时被调用

7、 onDestory -- Activity被销毁的时候被调用

为了能够比较直观看到这些函数是在什么时候被调用的。我们建立一个ActivityLifeCycle的工程，具体来操作一下。

[java]view plain copy 
    
 public class ActivityLife extends Activity {  
   
     final String TAG = "ActivityLife";  
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.activity_activity_life);  
     //打印当前调用的函数  
             Log.i(TAG, "it's the time calling onCreate");  
     }  
     @Override  
     protected void onStart() {  
         // TODO Auto-generated method stub  
         super.onStart();  
     //打印当前调用的函数  
         Log.i(TAG, "it's the time calling onStart");  
     }     
     @Override  
     protected void onRestart() {  
         // TODO Auto-generated method stub  
         super.onRestart();  
     //打印当前调用的函数  
         Log.i(TAG, "it's the time calling onRestart");  
     }  
       
     @Override  
     protected void onResume() {  
         // TODO Auto-generated method stub  
         super.onResume();  
     //打印当前调用的函数  
         Log.i(TAG, "it's the time calling onResume");  
     }  
     @Override  
     protected void onPause() {  
         // TODO Auto-generated method stub  
         super.onPause();  
     //打印当前调用的函数  
         Log.i(TAG, "it's the time calling onPause");  
     }  
     @Override  
     protected void onStop() {  
         // TODO Auto-generated method stub  
         super.onStop();  
     //打印当前调用的函数  
         Log.i(TAG, "it's the time calling onStop");  
     }      
     @Override  
     protected void onDestroy() {  
         // TODO Auto-generated method stub  
         super.onDestroy();  
     //打印当前调用的函数  
         Log.i(TAG, "it's the time calling onDestroy");  
     }  
 }  