Android生命周期详解
在Android 中，多数情况下每个程序都是在各自独立的Linux 进程中运行的。当一个程序或其某些部分被请求时，它的进程就“出生”了；当这个程序没有必要再运行下去且系统需要回收这个进程的内存用于其他程序时，这个进程就“死亡”了。可以看出，Android 程序的生命周期是由系统控制而非程序自身直接控制。这和我们编写桌面应用程序时的思维有一些不同，一个桌面应用程序的进程也是在其他进程或用户请求时被创建，但是往往是在程序自身收到关闭请求后执行一个特定的动作（比如从main 函数中return）而导致进程结束的。要想做好某种类型的程序或者某种平台下的程序的开发，最关键的就是要弄清楚这种类型的程序或整个平台下的程序的一般工作模式并熟记在心。在Android 中，程序的生命周期控制就是属于这个范畴——我的个人理解:)
在Android 系统中，当某个activity调用startActivity(myIntent) 时，系统会在所有已经安装的程序中寻找其intent filter 和myIntent 最匹配的一个activity，启动这个进程，并把这个intent 通知给这个activity。这就是一个程序的“生”。比如我们在Home application 中选择“Web browser”，系统会根据这个intent 找到并启动Web browser 程序，显示Web browser 的一个activity 供我们浏览网页（这个启动过程有点类似我们在在个人电脑上双击桌面上的一个图标，启动某个应用程序）。在Android 中，所有的应用程序“生来就是平等的”，所以不光Android 的核心程序甚至第三方程序也可以发出一个intent 来启动另外一个程序中的一个activity。Android 的这种设计非常有利于“程序部件”的重用。
一个Android 程序的进程是何时被系统结束的呢？通俗地说，一个即将被系统关闭的程序是系统在内存不足（low memory）时，根据“重要性层次”选出来的“牺牲品”。一个进程的重要性是根据其中运行的部件和部件的状态决定的。各种进程按照重要性从高到低排列如下：
1. 前台进程。这样的进程拥有一个在屏幕上显示并和用户交互的activity 或者它的一个IntentReciver 正在运行。这样的程序重要性最高，只有在系统内存非常低，万不得已时才会被结束。
2. 可见进程。在屏幕上显示，但是不在前台的程序。比如一个前台进程以对话框的形式显示在该进程前面。这样的进程也很重要，它们只有在系统没有足够内存运行所有前台进程时，才会被结束。
3. 服务进程。这样的进程在后台持续运行，比如后台音乐播放、后台数据上传下载等。这样的进程对用户来说一般很有用，所以只有当系统没有足够内存来维持所有的前台和可见进程时，才会被结束。
4. 后台进程。这样的程序拥有一个用户不可见的activity。这样的程序在系统内存不足时，按照LRU 的顺序被结束。
5. 空进程。这样的进程不包含任何活动的程序部件。系统可能随时关闭这类进程。
从某种意义上讲，垃圾收集机制把程序员从“内存管理噩梦”中解放出来，而Android 的进程生命周期管理机制把用户从“任务管理噩梦”中解放出来。我见过一些Nokia S60 用户和Windows Mobile 用户要么因为长期不关闭多余的应用程序而导致系统变慢，要么因为不时查看应用程序列表而影响使用体验。Android 使用Java 作为应用程序API，并且结合其独特的生命周期管理机制同时为开发者和使用者提供最大程度的便利。
Activity lifecycle
Activity有三种基本状态：
1.Active：处于屏幕前景（当前task的栈顶Activity处于Active状态），同一时刻只能有一个Activity
处于Active状态；
2.Paused状态：处于背景画面画面状态，失去了焦点，但依然是活动状态；
3.stopped：不可见，但依然保持所有的状态和内存信息。
可以调用finish()结束处理Paused或者stopped状态的Activity。
Activity的生命周期可以分为三组：
保存Activity状态
To capture that state before the activity is killed, you can implement
an onSaveInstanceState() method for the activity. Android calls this method before making the activity vulnerable to being destroyed — that is, before onPause() is called. It passes the method a Bundle object where you can record the dynamic state of the activity as name-value pairs. When the activity is again started, the Bundle is passed both
to onCreate() and to a method that's called
after onStart(),onRestoreInstanceState(), so that either or both of them can recreate the captured state.
Unlike onPause() and the other methods discussed
earlier, onSaveInstanceState() and onRestoreInstanceState()are not lifecycle methods. They are not always called. Because onSaveInstanceState() is not always called, you should use it only to record the transient state of the activity, not to store persistent https://www.doczj.com/doc/0113567990.html,e onPause() for that purpose instead.
启动另一个Activity的过程
?The current activity's onPause() method is called.
?Next, the starting activity's onCreate(), onStart(), and onResume() methods are called in sequence.
?Then, if the starting activity is no longer visible on screen, its onStop() method is called. service生命周期
A service can be used in two ways:
?It can be operated programmatically using an interface that it defines and exports.
Clients establish a connection to the Service object and use that connection to call into the service. The connection is established by calling Context.bindService(), and is closed by calling Context.unbindService(). Multiple clients can bind to the
same service. If the service has not already been launched, bindService() can
optionally launch it.
相关的方法：
voidonCreate()
void onStart(Intent intent)
void onDestroy()
The onCreate() and onDestroy() methods are called for all services, whether they're started by Context.startService() or Context.bindService().
However, onStart() is called only for services started by startService().
If a service permits others to bind to it, there are additional callback methods for it to implement:
IBinderonBind(Intent intent)
booleanonUnbind(Intent intent)
void onRebind(Intent intent)
Broadcast receiver lifecycle
只有一个方法：voidonReceive(Context curContext, Intent broadcastMsg)
A process with an active broadcast receiver is protected from being killed. But a process with only inactive components can be killed by the system at any time, when the memory it consumes is needed by other processes.
This presents a problem when the response to a broadcast message is time consuming and, therefore, something that should be done in a separate thread, away from the main thread where other components of the user interface run. If onReceive() spawns the thread and then returns, the entire process, including the new thread, is judged to be inactive (unless other application components are active in the process), putting it in jeopardy of being killed.
The solution to this problem is for onReceive() to start a service and let the service do the job, so the system knows that there is still active work being done in the process.
进程的生命周期
Android根据其重要性在内存不足的时候移去重要性最低的进程。重要性由高到低为：
1.前台进程
2.可见进程
3.服务进程
4.后台进程
5.空进程
注意：Because a process running a service is ranked higher than one with background activities, an activity that initiates a long-running operation might do well to start a service for that operation, rather than simply spawn a thread — particularly if the operation will likely outlast the activity. 比如播放MP3的时候就要启动一个service。
activity的生命周期演示：
activity的生命周期不管是在面试还是在工作中我们都会经常遇到，这当然也是非常基础的，基础也很重要哦，学会activity的生命周期对我们以后开发更健壮的程序会有很大帮助。下面来看一下Activity生命周期图
为了便于理解，我简单的写了一个Demo,不明白Activity周期的朋友们，可以亲手实践一下，大家按照我的步骤来。
第一步:新建一个Android工程，我这里命名为MainActivity.再创建一个OtherActivity继承activity。
源码打印？
源码打印？
第三步:运行上述工程,效果图如下(没什么特别的):
核心在Logcat视窗里，我们打开应用时先后执行了onCreate()->onStart()->onResume 三个方法，看一下LogCat视窗如下:
点击go按钮：
一定跳转到了另一个activity界面，下面让我们看看logcat：
当点击go按钮后首先执行mainActivity的onPause 然后依次执行otherActivity的onCreate（）onStart（）onResume（）方法，当整个屏幕被另一个activity完全遮挡住了调用mainActivity的onStop方法.
接下来点击back按钮：
这一次先是调用了otherActivity的onPuse方法，失去焦点，然后调用mainActivity的onStart onResume 接着就是otherActivity的停止，销毁。
从上面可以看出onCreate方法只调用一次，当一个activity失去焦点时，也就是不在最前端时调用onPause方法，当整个activity不可见时，也就是完全被另一个activity覆盖时，会调用onStop方法。
下面再让我们看下上面的Activity生命周期图是不是就容易理解了，当失去焦点时调用onPause方法，重新获得焦点调用OnResume方法这两个方法是相对的。完全被覆盖调用onStop方法，返回前端调用onStart方法。
然后在点击home键验证一下：
方法更详细的描述：
下面的表格对每个方法更详细的描述和在活动的整个生命周期中的定位。
注意上面表格的Killable列，它表示当方法返回时没有执行活动的其它代码，系统是否能
杀死活动寄宿的进程。三个方法（onPause()、onStop()、onDestroy()）标记为Yes。因为onPause()是唯一一个保证在进程被杀之前会调用的，因此你应该使用onPause()来写
任何持久化存储数据。
被标记为No的方法保护活动寄宿的进程在他们调用的时候不会被杀掉。因此活动是可杀掉状态，例如onPause()返回到onResume()调用期间。直到onPause()再次返回，活动是不可杀掉的。其实，没有标记为Killable的活动也是可以系统被杀掉的，不过这仅仅发生在
极端困难的情况下，没有有任何其他资源可用。
2、保存活动状态
当系统而不是用户关闭一个活动来节省内存时，用户可能希望返回到活动且是它之前的状态。为了获得活动被杀之前的状态，你可以执行活动的onSaveInstanceState()方法。Android
在活动容易被销毁前调用这个方法，也就是调用onPause()之前。该方法的参数是一个Bundle对象，在这个对象你可以以名值对记录活动的动态状态。当活动再次启动时，Bundle同时被传递到onCreate()和调用onCreate()之后的方法，onRestoreInstanceState()，因此使用一个或两个可以重新创建捕获的状态。
因为onSaveInstanceState()方法不总是被调用，你应该仅使用onSaveInstanceState()它
来记录活动的临时状态，而不是持久的数据。应该使用onPause()来存储持久数据。
3、协调活动
当一个活动启动另一个活动，他们都经历生命周期转换。一个暂停或许是停止，然而另一个启动。有时，你可能需要协调这些活动。生命周期的回调顺序是明确界定的，特别是当这两个活动在同一个进程中：
1.当前活动的onPause()方法被调用。
2.接下来，启动活动的onCreate()、onStart()、onResume()方法按序被调用。
3.然后，如果获得不再在屏幕上可见，它的onStop()方法被调用。
参考文献：https://www.doczj.com/doc/0113567990.html,/chen106106/blog/49060
https://www.doczj.com/doc/0113567990.html,/feisky/archive/2010/01/01/1637427.html
https://www.doczj.com/doc/0113567990.html,/blog/1163078#comments
学习并掌握Activity生命周期，对从事Android开发（或者打算日后从事这方面的开发工作）的朋友来讲，是至关重要的。本文将用图解和实例的方式，向大家详细讲解Activity 生命周期的有关知识。 Activity有三个状态： 1.当它在屏幕前台时（位于当前任务堆栈的顶部），它是激活或运行状态。它就是响应用户操作的Activity。 2.当它上面有另外一个Activity，使它失去了焦点但仍然对用户可见时（如图），它处于暂停状态。在它之上的Activity没有完全覆盖屏幕，或者是透明的，被暂停的Activity仍然对用户可见，并且是存活状态（它保留着所有的状态和成员信息并保持和窗口管理器的连接）。如果系统处于内存不足时会杀死这个Activity。
3.当它完全被另一个Activity覆盖时则处于停止状态。它仍然保留所有的状态和成员信息。然而对用户是不可见的，所以它的窗口将被隐藏，如果其它地方需要内存，则系统经常会杀死这个Activity。 当Activity从一种状态转变到另一种状态时，会调用以下保护方法来通知这种变化： void onCreate(Bundle savedInstanceState) void onStart()
void onRestart() void onResume() void onPause() void onStop() void onDestroy() 这七个方法定义了Activity的完整生命周期。实现这些方法可以帮助我们监视其中的三个嵌套生命周期循环： Activity的完整生命周期自第一次调用onCreate()开始，直至调用onDestroy()为止。Activity 在onCreate()中设置所有“全局”状态以完成初始化，而在onDestroy()中释放所有系统资源。例如，如果Activity有一个线程在后台运行从网络下载数据，它会在onCreate()创建线程，而在onDestroy()销毁线程。 Activity的可视生命周期自onStart()调用开始直到相应的onStop()调用结束。在此期间，用户可以在屏幕上看到Activity，尽管它也许并不是位于前台或者也不与用户进行交互。在这两个方法之间，我们可以保留用来向用户显示这个Activity所需的资源。例如，当用户不再看见我们显示的内容时，我们可以在onStart()中注册一个BroadcastReceiver来监控会影响UI的变化，而在onStop()中来注消。onStart() 和onStop() 方法可以随着应用程序是否为用户可见而被多次调用。 Activity的前台生命周期自onResume()调用起，至相应的onPause()调用为止。在此期间，Activity位于前台最上面并与用户进行交互。Activity会经常在暂停和恢复之间进行状态转换——例如当设备转入休眠状态或者有新的Activity启动时，将调用onPause() 方法。当
Android生命周期详解 在Android 中，多数情况下每个程序都是在各自独立的Linux 进程中运行的。当一个程序或其某些部分被请求时，它的进程就“出生”了；当这个程序没有必要再运行下去且系统需要回收这个进程的内存用于其他程序时，这个进程就“死亡”了。可以看出，Android 程序的生命周期是由系统控制而非程序自身直接控制。这和我们编写桌面应用程序时的思维有一些不同，一个桌面应用程序的进程也是在其他进程或用户请求时被创建，但是往往是在程序自身收到关闭请求后执行一个特定的动作（比如从main 函数中return）而导致进程结束的。要想做好某种类型的程序或者某种平台下的程序的开发，最关键的就是要弄清楚这种类型的程序或整个平台下的程序的一般工作模式并熟记在心。在Android 中，程序的生命周期控制就是属于这个范畴——我的个人理解:) 在Android 系统中，当某个activity调用startActivity(myIntent) 时，系统会在所有已经安装的程序中寻找其intent filter 和myIntent 最匹配的一个activity，启动这个进程，并把这个intent 通知给这个activity。这就是一个程序的“生”。比如我们在Home application 中选择“Web browser”，系统会根据这个intent 找到并启动Web browser 程序，显示Web browser 的一个activity 供我们浏览网页（这个启动过程有点类似我们在在个人电脑上双击桌面上的一个图标，启动某个应用程序）。在Android 中，所有的应用程序“生来就是平等的”，所以不光Android 的核心程序甚至第三方程序也可以发出一个intent 来启动另外一个程序中的一个activity。Android 的这种设计非常有利于“程序部件”的重用。
试题 一、选择题 1 android虚拟设备的缩写是（AVD） 2 Android SDK目前支持的操作系统（DOS） 3 Android开发工具插件(ADT)没有提供的开发功能（自动更新） 4Android SDK提供一些开发工具可以把应用软件打包成Android格式文件（APK） 5 Android当中基本的所有的UI都是由（view）或者其子类实现的 6以下不是Android中调试项目的正确步骤（测试用例） 7下列不是Activity的生命周期方法之一的是（OnResume） 8以下可以做EditText编辑框的提示信息是（adroid:hint） 9以下不是Activity启动的方法是（gotoActivity） 10以下不是手机操作系统的是（windows vista） 二、填空题 1 Android平台由操作系统，中间件，用户界面和应用软件组成的。 2 Android平台提供了2D，3D的图形支持，数据库支持SQLite,并且集成了浏览器 3目前已知的可以用来搭建Android开发环境的系统有windows,Linux,Mac 等4开发中推荐使用的IDE开发组合为IDE,eclipse,ADI来开发 5 Android SDK主要以java语言为基础 6创建工程时需要填写的信息名称有工程名，包的名字，Activity的名字还有应用的名字
7 Android.jar是一个标准的压缩包，其内容包含的是编译后的class，包含了全部的API 三、简答题 1 Android SDK中API的包结构的划分？至少五个 android.util，android.os，android.content，android.view，android.graphics，android.text 2 Android软件框架结构自上而下可分为哪些层？ 应用程序（Application）、应用程序框架（Application Framework）、各种库（Libraries）和Android运行环境（RunTime）、操作系统层（OS） 3 Android应用程序的4大组件是什么？ Activity、Broadcast Intent Receiver、Service、Content Provider 4 Android应用工程文件结构有哪些？ 源文件（包含Activity），R.java文件，Android Library，assets目录res目录，drawble目录，layout目录，values目录，AndroidManifest.xml 5 Android开发应用程序最有可能使用到的应用框架部分是哪些？ 一组View（UI）组件，Content Providers，Resource Manger，Notification Manger，Activiy Manger 6 Android底层库包含哪些？ 系统C库，媒体库，Surface Manager，LibWebCore，SGL 四、编程 1实现点击一个按钮，结束当前Activity并将需要返回的数据放置并关闭当前窗体请编写核心代码 Bundle bundle = new Bundle ( ); Bundle.putString(“store”,”数据来自Activity1”) ;
Android系统架构 Android目录结构 1.src目录 src目录中存放的是该项目的源代码，其内部结构会根据用户所声明的包自动组织，该
目录的组织方式为src/com/jiang/Main.java,程序员在项目开发过程中，大部分时间是对该目录下的源代码文件进行编写。 2.gen目录 该目录的文件是ADT自动生成的，并不需要人为地去修改，实际上该目录下只定义了一个R.java文件，该文件相当于项目的字典，项目中用户界面、字符串、图片、声音等资源都会在该类中创建其唯一的ID，当项目中使用这些资源时，会通过该类得到资源的引用。 3.Android2.2 该目录中存放的是该项目支持的JAR包，同时还包含项目打包时需要的META-INF目录。 4.assets目录 该目录用于存放项目相关的资源文件，例如文本文件等，在程序中可以使用”getResources.getAssets().open(“text.txt”)”得到资源文件的输入流InputStream对象。 5.res目录 该目录用于存放应用程序中经常使用的资源文件，包括图片、声音、布局文件及参数描述文件等，包括多个目录，其中以drawable开头的三个文件夹用于存储.png、.9.png、.jpg 等图片资源。layout文件夹存放的是应用程序的布局文件。raw用于存放应用程序所用到的声音等资源。value存放的则是所有XML格式的资源描述文件，例如字符串资源的描述文件strings.xml、样式的描述文件style.xml、颜色描述文件colors.xml、尺寸描述文件dimens.xml，以及数组描述文件arrays.xml等。 6.AndroidManifest.xml文件 该文件为应用程序定义了全局的配置信息。这个文件列出了应用程序所提供的功能，包括四大组件、版本、权限等等。在这个文件中，你可以指定应用程序使用到的服务(如电话服务、互联网服务、短信服务、GPS服务等等)。另外当你新添加一个Activity的时候，也需要在这个文件中进行相应配置，只有配置好后，才能调用此Activity。 android:versionCode是给设备程序识别版本(升级)。 android:versionName是给用户看的。 7.default.properties文件 该文件为项目的配置文件，不需要认为改动，系统会自动为其进行管理，其中主要描述了该项目的版本等信息。
Android开发历程_3(Activity生命周期) Activity中有7个与生命周期有关的函数。其中onCreated()是activity第一次被启动时执行的，主要是初始化一些变量，onRestart()是当前activity重新被启动时调用的；绑定一些监听器等；onStart()是activity界面被显示出来的时候执行的；onResume()是当该activity与用户能进行交互时被执行；onPause()是另一个activity被启动，当前的activity就被暂停了，一般在该函数中执行保存当前的数据；onStop()表示另一个activity被启动完成时，当前activity对用户同时又完全不可见时才调用的；onDestroy()是退出当前activity时调用的，当然如果程序中调用finish()或者说android系统当前资源不够用时就会被调用。 当用多个activity在执行时，这时候android系统会自动将这些activity压入栈中并且总是显示最顶的那个activity，这个栈在android叫做task，但是这个栈只支持压入和弹出操作，不支持排序插入等操作。 Activity的7个生命周期函数中的onStop()函数被调用时是在其对应的activity被另外的activity完全遮挡的时候，如果只有部分遮挡，则不会被调用。部分遮挡一般是以消息activtiy的形式出现，这个只需在AndroidManifest.xml中将其对于的activity的主题设置theme中更改即可。 这7个周期函数，当系统资源不够时，其中onPause(),onStop(),onDestroy()是有可能被系统kill掉的，但其它4个是不会被kill掉。 参考资料为mars老师的资料。 官方给出关于这7个生命周期的图如下：
Service 的生命周期回调函数 和Activity 一样，service 也有一系列的生命周期回调函数，你可以实现它们来监测service 状态的变化，并且在适当的时候执行适当的工作。 Like an activity, a service has lifecycle callback methods that you can implement to monitor changes in the service's state and perform work at the appropriate times. The following skeleton service demonstrates each of the lifecycle methods: 13
下面的service展示了每一个生命周期的方法： 【文件1-5】Service生命周期回调函数 1.public class TestService extends Service { 2.int mStartMode; //indicates how to behave if the service is killed 3.IBinder mBinder;// interface for clients that bind 4.boolean mAllowRebind;// indicates whether onRebind should be used 5. 6.@Override 7.public void onCreate() { 8.// The service is being created 9.} 10. 11.@Override 12.public int onStartCommand(Intent intent, int flags,int startId){ 13.// The service is starting, due to a call to startService() 14.return mStartMode; 15.} 16. 17.@Override 18.public IBinder onBind(Intent intent) { 19.// A client is binding to the service with bindService() 20.return mBinder; 21.} 22. 23.@Override 24.public boolean onUnbind(Intent intent) { 25.// All clients have unbound with unbindService() 26.return mAllowRebind; 27.} 28. 29.@Override 30.public void onRebind(Intent intent){ 31.// A client is binding to the service with bindService(), 32.// after onUnbind() has already been called 33.} 34. 35.@Override 36.public void onDestroy(){ 37.// The service is no longer used and is being destroyed 38.} 39.} 注意：不同于Activity的生命周期回调方法，Service不须调用父类的生命周期回调方法。 Unlike the activity lifecycle callback methods,you are not required to call the superclass implementation of these callback methods. 14
Android实验报告 专业：计算机科学与技术 班级： 学号： 姓名：武易 2016年11月28日 实验一Activity 生命周期 一、实验目的 Android 生命周期是从程序启动到程序终止的过程。通过本次实验深入理解Android 系统管理生命周期的必要性，并以Activity 为例说明Android 系统是如何管理程序组件的生命周期。 二、实验设备 1、硬件设备系统类型：Win7 版本32 位，处理器： Intel(R)Core(TM)i3-2350M CPU @2.30GHz 2.30GHz 安装内存 (RAM):8.00GB 2、软件设备Win7 操作系统、Eclipse、JDK、Android SDK、ADT 三、实验内容 1、实验要求 观察Activity的生命周期。 2、详细设计 public class MainActivity extends ActionBarActivity {
private static String TAG="LIFECYCLE"; @Override public void onCreate(Bundle savedInstanceState){ super.onCreate(savedInstanceState); Log.i(TAG,"(1) onCreate()"); button.setOnClickListener(new View.OnClickListener(){ public void onClick(View view){ finish(); } }); } @Override public void onStart(){ super.onStart(); Log.i(TAG,"(2) onStart()"); } @Override public void onRestoreInstanceState(Bundle savedInstanceState){ super.onRestoreInstanceState(savedInstanceState); Log.i(TAG,"(3) onRestoreInstanceState()"); } @Override
Android 应用程序的生命周期 Android 是一构建在Linux 之上的开源移动开发平台，在Android 中，多数情况下每个程序都是在各自独立的Linux 进程中运行的。当一个程序或其某些部分被请求时，它的进程就“出生”了；当这个程序没有必要再运行下去且系统需要回收这个进程的内存用于其他程序时，这个进程就“死亡”了。可以看出，Android 程序的生命周期是由系统控制而非程序自身直接控制。这和我们编写桌面应用程序时的思维有一些不同，一个桌面应用程序的进程也是在其他进程或用户请求时被创建，但是往往是在程序自身收到关闭请求后执行一个特定的动作（比如从main 函数中return）而导致进程结束的。要想做好某种类型的程序或者某种平台下的程序的开发，最关键的就是要弄清楚这种类型的程序或整个平台下的程序的一般工作模式并熟记在心。在Android中，程序的生命周期控制就是属于这个范畴——我的个人理解:) 在Android 系统中，当某个activity（应用程序的一个“帧”）调用startActivity(myIntent) 时，系统会在所有已经安装的程序中寻找其intent filter和myIntent 最匹配的一个activity，启动这个进程，并把这个intent通知给这个activity。这就是一个程序的“生”。比如我们在Home application 中选择“Web browser”，系统会根据这个intent 找到并启动Web browser 程序，显示Web browser 的一个activity 供我们浏览网页（这个启动过程有点类似我们在在个人电脑上双击桌面上的一个图标启动某个应用程序）。在Android 中，所有的应用程序“生来就是平等的”，所以不光Android 的核心程序甚至第三方程序也可以发出一个intent 来启动另外一个程序中的一个activity。Android 的这种设计非常有利于“程序部件”的重用。 一个Android 程序的进程是何时被系统结束的呢？通俗地说，一个即将被系统关闭的程序是系统在内存不足（low memory）时，根据“重要性层次”选出来的“牺牲品”。一个进程的重要性是根据其中运行的部件和部件的状态决定的。各种进程按照重要性从高到低排列如下： 1. 前台进程。这样的进程拥有一个在屏幕上显示并和用户交互的activity 或者它的一个IntentReciver 正在运行。这样的程序重要性最高，只有在系统内存非常低，万不得已时才会被结束。 2. 可见进程。在屏幕上显示，但是不在前台的程序。比如一个前台进程以对话框的形式显示在该进程前面。这样的进程也很重要，它们只有在系统没有足够内存运行所有前台进程时，才会被结束。 3. 服务进程。这样的进程在后台持续运行，比如后台音乐播放、后台数据上传下载等。这样的进程对用户来说一般很有用，所以只有当系统没有足够内存来维持所有的前台和可见进程时，才会被结束。 4. 后台进程。这样的程序拥有一个用户不可见的activity。这样的程序在系统内存不足时，按照LRU 的顺序被结束。 5. 空进程。这样的进程不包含任何活动的程序部件。系统可能随时关闭这类进程。 从某种意义上讲，垃圾收集机制把程序员从“内存管理噩梦”中解放出来，而Android 的进程生命周期管理机制把用户从“任务管理噩梦”中解放出来。我见过一些Nokia S60 用户和Windows Mobile 用户要么因为长期不关闭多余的应用程序而导致系统变慢，要么因为不时查看应用程序列表而影响使用体验。Android 使用Java 作为应用程序API，并且结合其独特的生命周期管理机制同时为开发者和使用者提供最大程度的便利。
android点滴(12) -- 1. Android横竖屏切换时，Activity的生命周期的变化 (面试题) 2011/10/15 10:49:48 | 阅读40次 1.Android横竖屏切换时，Activity的生命周期的变化。 Activity的生命周期 /Files/cod y1988/ActivityLifeCycle.rar 完整生命周期(the entire lifetime) onCreate , onDestroy 在创建和销毁的时候调用。在onCreate中初始化全局资源，在onDestroy中销毁资源。
可见生命周期(the visible lifetime) onStart , onStop 这是Activity可见，但是未必可交互即未必在最前面。维护着用户可见的资源。 前景周期(the for eground lifetime) onResume , onPause 此时Activity在最前面，可与用户交互。一个Activity 可在Resume与Pause之间频繁的切换例如设备休眠。因此这两个方法中只有相当轻量级的调用。 横竖屏切换时Activity的生命周期的变化与activity的configChanges的配置有关。 1.configChanges不配置 运行： 初始时TextView显示的内容为“Hello World, LifeCycle!”，点击Button
竖屏切换为横屏： 此时TextView的内容重新变为“Hello World, LifeCycle!” 横屏切换为竖屏：
2.配置configChanges
Android 开发 （实验四） 实验题目：Activity生命周期验证试验指导老师： 班级：计算机科学与技术系班 姓名：（
一、实验目的 1、深入理解Activity运行机制和原理。 2、掌握Activity的声明周期各个阶段工作流程。 3、掌握多个Activity之间生命周期的转换过程。 4、通络Intent实现多页面之间数据的传递(辅助完成)。 二、实验内容 1、搭建任意组件，设计多个界面，运行程序观察其生命周期的 情况。 2、使用Intent实现页面之间数据的传递。 三、实验代码 AlifecyfleActivity.java package com.wr; import android.app.Activity; import android.content.Intent; import android.os.Bundle; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; public class AlifecycleActivity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(https://www.doczj.com/doc/0113567990.html,yout.main); Button BtnStart = (Button) findViewById(R.id.BtnStart); BtnStart.setOnClickListener(new MyBtnClickListener()); } @Override protected void onDestroy() { // TODO Auto-generated method stub super.onDestroy();
在Android 中，多数情况下每个程序都是在各自独立的Linux 进程中运行的。当一个程序或其某些部分被请求时，它的进程就“出生”了；当这个程序没有必要再运行下去且系统需要回收这个进程的内存用于其他程序时，这个进程就“死亡”了。可以看出，Android 程序的生命周期是由系统控制而非程序自身直接控制。这和我们编写桌面应用程序时的思维有一些不同，一个桌面应用程序的进程也是在其他进程或用户请求时被创建，但是往往是在程序自身收到关闭请求后执行一个特定的动作（比如从main 函数中return）而导致进程结束的。要想做好某种类型的程序或者某种平台下的程序的开发，最关键的就是要弄清楚这种类型的程序或整个平台下的程序的一般工作模式并熟记在心。在Android 中，程序的生命周期控制就是属于这个范畴——我的个人理解:) 在Android 系统中，当某个activity调用 startActivity(myIntent) 时，系统会在所有已经安装的程序中寻找其intent filter 和myIntent 最匹配的一个activity，启动这个进程，并把这个intent 通知给这个activity。这就是一个程序的“生”。比如我们在Home application 中选择“Web browser”，系统会根据这个intent 找到并启动Web browser 程序，显示Web browser 的一个activity 供我们浏览网页（这个启动过程有点类似我们在在个人电脑上双击桌面上的一个图标，启动某个应用程序）。在Android 中，所有的应用程序“生来就是平等的”，所以不光Android 的核心程序甚至第三方程序也可以发出一个intent
Android特点突出，灵活易用。它在界面开发中，应用构成；布局管理；以及其生命周期中都体现了非常大的优势。在这里将会对此一一详细介绍。 Android手机操作系统的推出，大大受到广大编程人员的喜爱。那么它究竟有什么出色的特点吸引着人们的眼光呢？我们在这里就为大家总结了一些Android特点，以供对此有兴趣的朋友参考学习。 1. Android是什么？ Android是一个平台，主要包括Linux微内核，中间件（SQLite等），关键应用（电话本、邮件、短消息、GoogleMap、浏览器等），提供的Java框架，以及Android中的JVM。 2.Android特点之关键类 视图，ContentProviders（应用交互管理类）、ResourceManager非编码资源管理类、NotificationManager （通告管理类）、ActivityManager（生命周期管理类）。 3.Android特点之界面开发 这一块主要讨论了Android的界面开发机制，可以讲组件的初始化抽取出来放到配置文件中，组件更新用编码方式来处理。 4.应用构成 Android的应用一般由以下四个关键部分构成Activity、IntentReceiver、Service、ContentProvider。其中Activity是必要部分。 应用场合： Activity每个应用都是必须得，Activity代表一个应用的一个具体的界面管理类，其本身并不显示。 IntentReceiver可使应用对外部事件做出响应，比如，当应用正在执行，突然有了来电，这个时候可使用IntentReceiver做出处理是应用更健壮。 Service Android应用的生命周期是由Android系统来决定的，不由具体的应用的线程左右。当应用要求在没有界面显示的情况还能正常运行，（要求有后台线程，而后台线程是不会被系统回收，直到线程结束）这个时候就需要用到Service ContentProvider 可以说ContentProvider封装很多Android当中的上下文环境，包括SQLite，这就使得在不同应用之间交互成为可能。 5.Android特点之布局管理 FrameLayout：左上角只显示一个组件。 LinearLayout：线性布局管理器，分为水平和垂直俩中，只能进行单行布局。
Android框架及Activity 生命周期程序设计 实验目的： 本实验的目的是使学生深入了解Android程序框架结构、了解Android组件的生命周期中各状态的变化关系、掌握Android应用程序的调试方法和工具。通过程序设计，掌握Activity的三种生命周期：全生命周期、可视生命周期和活动生命周期；每种生命周期中包含的不同的事件回调函数，以及它们的作用和调用顺序，深入理解Activity的生命周期过程。 实验要求： 根据下图，设计程序解释不同的事件回调函数在Activity的三种生命周期的作用如何。 [实现提示] 1、建立Android工程，其中 工程名称：ActivityLifeCycle你的学号 包名称：https://www.doczj.com/doc/0113567990.html,.bistu.你的班级号. ActivityLifeCycle你的学号 Activity名称：ActivityLifeCycle你的学号 如：电技1001班学号后三位为123的学生，应将包名称设为：https://www.doczj.com/doc/0113567990.html,.bistu.dj1001. ActivityLifeCycle123
2、工程建立完毕后，可以不进行界面设计，即不必修改main.xml文件，直接编写Java文件 3、通过在生命周期函数中添加“日志点”的方法进行调试 4、为了显示结果易于观察和分析，在LogCat设置过滤器LifeCycleFilter 测试过程 在程序运行过程，通过点击模拟器上的“返回键”，生命周期中事件回调函数的执行顺序及作用是函数的调用顺序：onSaveInstanceState ()→onPause()→onStop() →onRestart()→onStart()→onResume()；调用onSaveInstanceState()函数保存Activity状态；调用onPause()和onStop()，停止对不可见Activity的更新；调用onRestart()恢复需要界面上需要更新的信息；调用onStart()和onResume()重新显示Activity，并接受用户交互。 程序源码： package https://www.doczj.com/doc/0113567990.html,.bistu.dj1001.ActivityLifeCycle123; import android.app.Activity; import android.os.Bundle; import android.util.Log; public class ActivityLifeCycle123 extends Activity { private static String TAG="LIFECYCLE"; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(https://www.doczj.com/doc/0113567990.html,yout.main); Log.i(TAG, "(1)onCreate()"); } @Override protected void onStart() { // TODO Auto-generated method stub super.onStart(); Log.i(TAG, "(2)onStart()"); } @Override protected void onRestoreInstanceState(Bundle savedInstanceState) { // TODO Auto-generated method stub super.onRestoreInstanceState(savedInstanceState); Log.i(TAG, "(3)onRestoreInstanceState()");
Android应用程序的生命周期 描述：程序的生命周期是在Android系统中进程从启动到终止的所有阶段，也就是Android从启动到停止的全过程。==程序的生命周期是由Android系统进行调度和控制的。 ①程序生命周期 a) Android进程的优先级。 前台进程==》 可见进程 ==》服务进程==》 后台进程==》空进程 说明： ㈠前台进程： 是Android系统中最重要的进程，是与用户 正在进行交互的进程。有以下四种情 况。·Activity正在与用户进行交互·进程 被Activity调用，而且这个进程正在与用户
进行交互·进程服务正在执行声明中的回调函数，如OnCreate（）OnStart（）OnDestroy （）·进程的BroadCastReceiver在执行 OnReceive（）函数 Android系统在多个前台进程同时运行时， 可能会出现资源部足的情况，此时会清除部分前台进程，保证主要的用户界面能够及时响应。 ㈡可见进程 是指部分程序界面能够被用户看见，却不在前台与用户交互，不影响界面事件的进程。 如果一个进程包含服务，且这个服务正被用户可见的Activity调用，此进程同样被视 为可见进程。 Androdi进程一般存在少量的可见进程，只 有在特殊情况下，Android系统才会为保证 前台进程的资源而清除可见进程。 ㈢服务进程
服务进程是指包含已启动服务的进程。·没有用户界面·在后台长期运行 Android系统除非不能保证前台进程和可见 进程所必要的资源，否则不强行清 除服务进程。 ㈣后台进程 后台进程是指不包括任何已经启动的服务，而其没有任何用户可见的Activity的进程 Android系统中一般存在数量较多的后台进 程，在系统资源紧张时，系统将优先清除用户较长时间没有见到的后台进程 ㈤空进程 空进程是不包含任何活跃组件的进程 空进程在系统紧张时会被首先清除。但为了提高Android应用程序的启动速 度，Android系统会将空进程保存在系统内 存用，在用户重新启动该程序时，空进程会被重新使用。
Android基础之四大基本组件介绍与生命周期 Android四大基本组件分别是Activity，Service服务,Content Provider 内容提供者，BroadcastReceiver广播接收器。 一:了解四大基本组件 Activity : 应用程序中，一个Activity通常就是一个单独的屏幕，它上面可以显示一些控件也可以监听并处理用户的事件做出响应。 Activity之间通过Intent进行通信。在Intent 的描述结构中，有两个最重要的部分：动作和动作对应的数据。 典型的动作类型有：M AIN（activity的门户）、VIEW、PICK、EDIT 等。而动作对应的数据则以URI 的形式进行表示。例如：要查看一个人的联系方式，你需要创建一个动作类型为VIEW 的intent，以及一个表示这个人的URI。 与之有关系的一个类叫IntentFilter。相对于intent 是一个有效的做某事的请求，一个intentfilter 则用于描述一个activity（或者IntentReceiver）能够操作哪些intent。一个activity 如果要显示一个人的联系方式时，需要声明一个IntentFilter，这个IntentFilter 要知道怎么去处理VIEW 动作和表示一个人的URI。IntentFilter 需要在AndroidManifest.xml 中定义。通过解析各种intent，从一个屏幕导航到另一个屏幕是很简单的。当向前导航时，activity 将会调用startActivity(Intent myIntent)方法。然后，系统会在所有安装的应用程序中定义的IntentFilter 中查找，找到最匹配myIntent 的Intent 对应的activity。新的activity 接收到
实验一 Android环境构建与Activity生命周期 【目的】 安装智能手机开发相关软件平台,并在此基础上测试Activity的生命周期过程。 【要求】 1、完成智能手机开发平台安装、以及相关配置； 2、并实现Hello World； 3、添加Log日志，通过Log日志验证Activity生命周期中的7个方法执行过程； 4、了解项目的基本文件目录结构，了解Activity周期中的4种状态。 【原理】 1、Android程序基本组成结构 Android应用程序的基本组成结构如图2-1。 src/ java原代码存放目录 该目录是专门用来存放应用程序java源码的。日后 编写代码，基本在这个目录下进行。 gen/自动生成目录 gen 目录中存放所有由Android开发工具自动生成 的文件。目录中最重要的就是R.java文件。这个文件由 Android开发工具自动产生的。Android开发工具会自动 根据你放入res目录的xml界面文件、图标与常量，同 步更新修改R.java文件。正因为R.java文件是由开发工 具自动生成的，所以我们应避免手工修改R.java。R.java
在应用中起到了字典的作用，它包含了界面、图标、常量等各种资源的id，通过R.java，应用可以很方便地找到对应资源。另外编绎器也会检查R.java列表中的资源是否被使用到，没有被使用到的资源不会编绎进软件中，这样可以减少应用在手机占用的空间。 Android 4.1.2 该目录主要存放Android SDK的jar包，是根据新建工程时候选用的SDK版本来确定的，指向SDK开发版本目录下的jar包。 Android Dependencies 该目录主要存放本工程Android自动加载的依赖Jar包。 assets/ 资源目录 主要存放应用程序中使用的外部资源文件，如声音视频等，在Android程序中可以通过输入/输出流对该目录中的文件进行读写。但由于存放在assets目录下的资源文件不会在R.java自动生成ID，所以读取/assets目录下的文件必须指定文件的路径。 bin/ 存放2进制文件目录 res/ 资源(Resource)目录 在这个目录中我们可以存放应用使用到的的图片、界面布局 文件及XML格式的描述文件等各种资源。存放在个目录下的资源 文件格式有严格的定义，会相应在R.java中自动生成ID。 该目录下包含以下子目录（如图2-2）： ?drawable：主要存放图片资源，目录下一般会有三个目 录分别存放高中低三种不同分辨率的图片 ?layout：该目录下存放的是手机界面显示的布局文件 ?values：主要存放一些资源变量值的配置文件 menu: 主要存放菜单文件 2、AndroidManifest.xml的结构和规则 AndroidManifest.xml文件的结构、元素，以及元素的属性，可以在Android SDK文档中查看详细说明。而在看这些众多的元素以及元素的属性前，需要先了解一下这些元素在命名、结构等方面的规则： ?元素：在所有的元素中只有