转载:http://blog.csdn.net/lmj/article/details/
1、Context概念Context，相信不管是第一天开发Android，还是开发Android的各种老鸟，对于Context的使用一定不陌生~~你在加载资源、启动一个新的Activity、获取系统服务、获取内部文件（夹）路径、创建View操作时等都需要Context的参与，可见Context的常见性。大家可能会问到底什么是Context，Context字面意思上下文，或者叫做场景，也就是用户与操作系统操作的一个过程，比如你打电话，场景包括电话程序对应的界面，以及隐藏在背后的数据； 但是在程序的角度Context又是什么呢？在程序的角度，我们可以有比较权威的答案，Context是个抽象类，我们可以直接通过看其类结构来说明答案：
可以看到Activity、Service、Application都是Context的子类；也就是说，Android系统的角度来理解：Context是一个场景，代表与操作系统的交互的一种过程。从程序的角度上来理解：Context是个抽象类，而Activity、Service、Application等都是该类的一个实现。在仔细看一下上图：Activity、Service、Application都是继承自ContextWrapper，而ContextWrapper内部会包含一个base context，由这个base context去实现了绝大多数的方法。
2、Context与ApplicationContext看了标题，千万不要被误解，ApplicationContext并没有这个类，其实更应该叫做：Activity与Application在作为Context时的区别。嗯，的确是这样的，大家在需要Context的时候，如果是在Activity中，大多直接传个this，当在匿名内部类的时候，因为this不能用，需要写XXXActivity.this，很多哥们会偷懒，直接就来个getApplicationContext。那么大家有没有想过，XXXActivity.this和getApplicationContext的区别呢？XXXActivity和getApplicationContext返回的肯定不是一个对象，一个是当前Activity的实例，一个是项目的Application的实例。既然区别这么明显，那么各自的使用场景肯定不同，乱使用可能会带来一些问题。下面开始介绍在使用Context时，需要注意的问题。
3、引用的保持大家在编写一些类时，例如工具类，可能会编写成单例的方式，这些工具类大多需要去访问资源，也就说需要Context的参与。在这样的情况下，就需要注意Context的引用问题。例如以下的写法：
1 package com.mooc.shader.
3 import android.content.C
5 public class CustomManager
private static CustomManager sI
private Context mC
private CustomManager(Context context)
this.mContext =
public static synchronized CustomManager getInstance(Context context)
if (sInstance == null)
sInstance = new CustomManager(context);
//some methods
private void someOtherMethodNeedContext()
对于上述的单例，大家应该都不陌生（请别计较getInstance的效率问题），内部保持了一个Context的引用；这么写是没有问题的，问题在于，这个Context哪来的我们不能确定，很大的可能性，你在某个Activity里面为了方便，直接传了个这样问题就来了，我们的这个类中的sInstance是一个static且强引用的，在其内部引用了一个Activity作为Context，也就是说，我们的这个Activity只要我们的项目活着，就没有办法进行内存回收。而我们的Activity的生命周期肯定没这么长，所以造成了内存泄漏。那么，我们如何才能避免这样的问题呢？有人会说，我们可以软引用，嗯，软引用，假如被回收了，你不怕NullPointException么。把上述代码做下修改：
1 public static synchronized CustomManager getInstance(Context context)
if (sInstance == null)
sInstance = new CustomManager(context.getApplicationContext());
这样，我们就解决了内存泄漏的问题，因为我们引用的是一个ApplicationContext，它的生命周期和我们的单例对象一致。这样的话，可能有人会说，早说嘛，那我们以后都这么用不就行了，很遗憾的说，不行。上面我们已经说过，Context和Application Context的区别是很大的，也就是说，他们的应用场景（你也可以认为是能力）是不同的，并非所有Activity为Context的场景，Application Context都能搞定。下面就开始介绍各种Context的应用场景。
4、Context的应用场景
大家注意看到有一些NO上添加了一些数字，其实这些从能力上来说是YES，但是为什么说是NO呢？下面一个一个解释：数字1：启动Activity在这些类中是可以的，但是需要创建一个新的task。一般情况不推荐。数字2：在这些类中去layout inflate是合法的，但是会使用系统默认的主题样式，如果你自定义了某些样式可能不会被使用。数字3：在receiver为null时允许，在4.2或以上的版本中，用于获取黏性广播的当前值。（可以无视）注：ContentProvider、BroadcastReceiver之所以在上述表格中，是因为在其内部方法中都有一个context用于使用。
好了，这里我们看下表格，重点看Activity和Application，可以看到，和UI相关的方法基本都不建议或者不可使用Application，并且，前三个操作基本不可能在Application中出现。实际上，只要把握住一点，凡是跟UI相关的，都应该使用Activity做为Context来处理；其他的一些操作，Service,Activity,Application等实例都可以，当然了，注意Context引用的持有，防止内存泄漏。
5、总结好了，到此，Context的分析基本完成了，希望大家在以后的使用过程中，能够稍微考虑下，这里使用Activity合适吗？会不会造成内存泄漏？这里传入Application work吗？
阅读(...) 评论()&nbsp>&nbsp
&nbsp>&nbsp
&nbsp>&nbsp
Android深入理解Context（一）Context关联类和Application Context创建过程
摘要：相关文章Android深入四大组件系列前言Context也就是上下文对象,是Android较为常用的类,但是对于Context,很多人都停留在会用的阶段,这个系列会带大家从源码角度来分析Context,从而更加深入的理解它。1.Context概述Context意为上下文或者场景,是一个应用程序环境信息的接口。在开发中我们经常会使用Context,它的使用场景总的来说分为两大类,它们分别是:使用Context调用方法,比如:启动Activity、访问资源、调用系统级服务等。调用
相关文章Android深入四大组件系列
Context也就是上下文对象,是Android较为常用的类,但是对于Context,很多人都停留在会用的阶段,这个系列会带大家从源码角度来分析Context,从而更加深入的理解它。
1.Context概述
Context意为上下文或者场景,是一个应用程序环境信息的接口。在开发中我们经常会使用Context,它的使用场景总的来说分为两大类,它们分别是:
使用Context调用方法,比如:启动Activity、访问资源、调用系统级服务等。
调用方法时传入Context,比如:弹出Toast、创建Dialog等。
Activity、Service和Application都是间接的继承自Context的,因此,我们可以计算出应用程序中有多少个Context,这个数量等于Activity和Service的总个数加1,1指的是Application的数量。
Context是一个抽象类,它的内部定义了很多方法以及静态常量,它的具体实现类为ContextImpl。和Context相关联的类,除了ContextImpl还有ContextWrapper、ContextThemeWrapper和Activity等等,下面给出Context的关系图。
从图中我们可以看出,ContextImpl和ContextWrapper继承自Context,ContextThemeWrapper、Service和Application继承自ContextWrapper。ContextWrapper和ContextThemeWrapper都是Context的包装类,它们都含有Context类型的mBase对象,mBase具体指向的是ContextImpl,这样通过ContextWrapper和ContextThemeWrapper也可以使用Context的方法。ContextThemeWrapper中包含和主题相关的方法(比如: getTheme方法),因此,需要主题的Activity继承ContextThemeWrapper,而不需要主题的Service则继承ContextWrapper。
2.Application Context的创建过程
我们通过调用getApplicationContext来获取应用程序的全局的Application Context,那么Application Context是如何创建的呢?当一个应用程序启动完成后,应用程序就会有一个全局的Application Context。那么我们就从应用程序启动过程开始着手。
在Android深入四大组件(一)应用程序启动过程(后篇)这篇文章的最后讲了ActivityThread启动Activity。ActivityThread作为应用程序进程的核心类,它会调用它的内部类ApplicationThread的scheduleLaunchActivity方法来启动Activity,如下所示。
frameworks/base/core/java/android/app/ActivityThread.java
private class ApplicationThread extends ApplicationThreadNative {
public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
ActivityInfo info, Configuration curConfig, Configuration overrideConfig,
CompatibilityInfo compatInfo, String referrer, IVoiceInteractor voiceInteractor,
int procState, Bundle state, PersistableBundle persistentState,
List&ResultInfo& pendingResults, List&ReferrerIntent& pendingNewIntents,
boolean notResumed, boolean isForward, ProfilerInfo profilerInfo) {
updateProcessState(procState, false);
ActivityClientRecord r = new ActivityClientRecord();
sendMessage(H.LAUNCH_ACTIVITY, r);
在ApplicationThread的scheduleLaunchActivity方法中向H类发送LAUNCH_ACTIVITY类型的消息,目的是将启动Activity的逻辑放在主线程中的消息队列中,这样启动Activity的逻辑会在主线程中执行。我们接着查看H类的handleMessage方法对LAUNCH_ACTIVITY类型的消息的处理。
frameworks/base/core/java/android/app/ActivityThread.java
private class H extends Handler {
public static final int LAUNCH_ACTIVITY = 100;
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, &&&& handling: & + codeToString(msg.what));
switch (msg.what) {
case LAUNCH_ACTIVITY: {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, &activityStart&);
final ActivityClientRecord r = (ActivityClientRecord) msg.
r.packageInfo = getPackageInfoNoCheck(
r.activityInfo.applicationInfo, r.compatInfo);//1
handleLaunchActivity(r, null, &LAUNCH_ACTIVITY&);//2
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
H继承自Handler ,是ActivityThread的内部类。在注释1处通过getPackageInfoNoCheck方法获得LoadedApk类型的对象,并将该对象赋值给ActivityClientRecord 的成员变量packageInfo,其中LoadedApk用来描述已加载的APK文件。在注释2处调用handleLaunchActivity方法,如下所示。frameworks/base/core/java/android/app/ActivityThread.java
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent, String reason) {
Activity a = performLaunchActivity(r, customIntent);
我们接着查看performLaunchActivity方法:frameworks/base/core/java/android/app/ActivityThread.java
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
performLaunchActivity方法中有很多重要的逻辑,这里只保留了Application Context相关的逻辑,想要更多了解performLaunchActivity方法中的逻辑请查看Android深入四大组件(一)应用程序启动过程(后篇)这篇文章的第二小节。这里ActivityClientRecord 的成员变量packageInfo是LoadedApk类型的,我们接着来查看LoadedApk的makeApplication方法,如下所示。frameworks/base/core/java/android/app/LoadedApk.java
public Application makeApplication(boolean forceDefaultAppClass,
Instrumentation instrumentation) {
if (mApplication != null) {//1
java.lang.ClassLoader cl = getClassLoader();
ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);//2
app = mActivityThread.mInstrumentation.newApplication(
cl, appClass, appContext);//3
appContext.setOuterContext(app);//4
} catch (Exception e) {
mActivityThread.mAllApplications.add(app);
mApplication =//5
注释1处如果mApplication不为null则返回mApplication,这里假设是第一次启动应用程序,因此mApplication为null。在注释2处通过ContextImpl的createAppContext方法来创建ContextImpl。注释3处的代码用来创建Application,在Instrumentation的newApplication方法中传入了ClassLoader类型的对象以及注释2处创建的ContextImpl 。在注释4处将Application赋值给ContextImpl的Context类型的成员变量mOuterContext。注释5处将Application赋值给LoadedApk的成员变量mApplication,在Application Context的获取过程中我们会再次用到mApplication。我们来查看注释3处的Application是如何创建的,Instrumentation的newApplication方法如下所示。frameworks/base/core/java/android/app/Instrumentation.java
static public Application newApplication(Class&?& clazz, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
Application app = (Application)clazz.newInstance();//1
app.attach(context);
Instrumentation中有两个newApplication重载方法,最终会调用上面这个重载方法。注释1处通过反射来创建Application,并调用了Application的attach方法,并将ContextImpl传进去:frameworks/base/core/java/android/app/Application.java
/* package */ final void attach(Context context) {
attachBaseContext(context);
mLoadedApk = ContextImpl.getImpl(context).mPackageI
attach方法中调用了attachBaseContext方法,它的实现在Application的父类ContextWrapper中,代码如下所示。frameworks/base/core/java/android/content/ContextWrapper.java
protected void attachBaseContext(Context base) {
if (mBase != null) {
throw new IllegalStateException(&Base context already set&);
从上文我们得知,这个base指的是ContextImpl,将ContextImpl赋值给ContextWrapper的Context类型的成员变量mBase。Application Context的创建过程就讲到这里,最后给出Application Context创建过程的时序图。
3.Application Context的获取过程
当我们熟知了Application Context的创建过程,那么它的获取过程会非常好理解。我们通过调用getApplicationContext方法来获得Application Context,getApplicationContext方法的实现在ContextWrapper中,如下所示。frameworks/base/core/java/android/content/ContextWrapper.java
public Context getApplicationContext() {
return mBase.getApplicationContext();
从上文我们得知,mBase指的是ContextImpl,我们来查看 ContextImpl的getApplicationContext方法:frameworks/base/core/java/android/app/ContextImpl.java
public Context getApplicationContext() {
return (mPackageInfo != null) ?
mPackageInfo.getApplication() : mMainThread.getApplication();
如果LoadedApk不为null,则调用LoadedApk的getApplication方法,否则调用AvtivityThread的getApplication方法。由于应用程序这时已经启动,因此LoadedApk不会为null,则会调用LoadedApk的getApplication方法:frameworks/base/core/java/android/app/LoadedApk.java
Application getApplication() {
这里的mApplication我们应该很熟悉,它在上文LoadedApk的makeApplication方法的注释5处被赋值。这样我们通过getApplicationContext方法就获取到了Application Context。
欢迎关注我的微信公众号,第一时间获得博客更新提醒,以及更多成体系的Android相关原创技术干货。扫一扫下方二维码或者长按识别二维码,即可关注。
以上是的内容，更多
的内容，请您使用右上方搜索功能获取相关信息。
若你要投稿、删除文章请联系邮箱：zixun-group@service.aliyun.com,工作人员会在五个工作日内给你回复。
云服务器 ECS
可弹性伸缩、安全稳定、简单易用
&40.8元/月起
预测未发生的攻击
&24元/月起
为您提供0门槛上云实践机会
你可能还喜欢
你可能感兴趣
阿里云教程中心为您免费提供
Android深入理解Context（一）Context关联类和Application Context创建过程相关信息，包括
的信息，所有Android深入理解Context（一）Context关联类和Application Context创建过程相关内容均不代表阿里云的意见！投稿删除文章请联系邮箱：zixun-group@service.aliyun.com，工作人员会在五个工作日内答复
售前咨询热线
服务与支持
资源和社区
关注阿里云
International他的最新文章
他的热门文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)47被浏览3,586分享邀请回答
* Same as {@link #startActivity(Intent, Bundle)} with no options
* specified.
* @param intent The description of the activity to start.
* @throws ActivityNotFoundException &
* @see #startActivity(Intent, Bundle)
* @see PackageManager#resolveActivity
public abstract void startActivity(Intent intent);
2. Context
的一个子类叫 ContextWrapper ，ContextWrapper
虽然实现了 startActivity (Intent) 方法，但是很简单，因为需要实例化，所以必须要实现父类中的 abstract 方法。
public void startActivity(Intent intent) {
mBase.startActivity(intent);
3. ContextWrapper
有一个子类叫 ContextThemeWrapper ，这个类并没有实现startActivity(Intent) 方法。4. Activity 的定义如下：public class Activity extends ContextThemeWrapper
implements LayoutInflater.Factory2,
Window.Callback, KeyEvent.Callback,
OnCreateContextMenuListener, ComponentCallbacks2,
Window.OnWindowDismissedCallback {
其实现了 startActivity(Intent) 方法：
* Same as {@link #startActivity(Intent, Bundle)} with no options
* specified.
* @param intent The intent to start.
* @throws android.content.ActivityNotFoundException
* @see {@link #startActivity(Intent, Bundle)}
* @see #startActivityForResult
public void startActivity(Intent intent) {
this.startActivity(intent, null);
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
// Note we want to go through this call for compatibility with
// applications that may have overridden the method.
startActivityForResult(intent, -1);
所以结论就是，这两个货是一样的...你在调用的时候，其实最终调用的都是 Activity 类实现的 startActivity 方法。之所以会有这样的写法，是因为下面两个在 Activity 中是等价的this.startActivity(intent);
context.startActivity(intent);
另外 Context 的子类也有其他实现 startActivity 的，比如 ContextImpl.java， 这时候就需要一个 flag ：FLAG_ACTIVITY_NEW_TASK ，否则就会抛出异常。
public void startActivity(Intent intent, Bundle options) {
warnIfCallingFromSystemProcess();
if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) {
throw new AndroidRuntimeException(
"Calling startActivity() from outside of an Activity "
+ " context requires the FLAG_ACTIVITY_NEW_TASK flag."
+ " Is this really what you want?");
mMainThread.getInstrumentation().execStartActivity(
getOuterContext(), mMainThread.getApplicationThread(), null,
(Activity) null, intent, -1, options);
至于为什么非 Activity 实现的 startActivity
方法需要加这个 flag ， 是因为在 Activity 的 startActivity 的实现中，会判断如果没有这个 flag ， 就会自动把这个新的 Activity 加到现有的 task 里面。而其他的 Context 或者其子类的实现中， 是没有这种判断的， 所以需要使用者指定这个 flag ，以便 AMS 将其加入到其自己的 task 中。373 条评论分享收藏感谢收起0添加评论分享收藏感谢收起写回答他的最新文章
他的热门文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)}