首页 > 其他分享> > Android面试大全基础篇（校招+社招，安卓面试宝典

Android面试大全基础篇（校招+社招，安卓面试宝典

2021-11-25 18:02:24 作者：互联网

START_NOT_STICKY：如果返回START_NOT_STICKY，表示当Service运行的进程被Android系统强制杀掉之后，不会重新创建该Service。

START_STICKY：如果返回START_STICKY，表示Service运行的进程被Android系统强制杀掉之后，Android系统会将该Service依然设置为started状态（即运行状态），但是不再保存onStartCommand方法传入的intent对象，即获取不到intent的相关信息。

START_REDELIVER_INTENT：如果返回START_REDELIVER_INTENT，表示Service运行的进程被Android系统强制杀掉之后，与返回START_STICKY的情况类似，Android系统会将再次重新创建该Service，并执行onStartCommand回调方法，但是不同的是，Android系统会再次将Service在被杀掉之前最后一次传入onStartCommand方法中的Intent再次保留下来并再次传入到重新创建后的Service的onStartCommand方法中，这样我们就能读取到intent参数。

4， BroadcastReceiver

4.1 BroadcastReceiver是什么

BroadcastReceiver，广播接收者，它是一个系统全局的监听器，用于监听系统全局的Broadcast消息，所以它可以很方便的进行系统组件之间的通信。BroadcastReceiver属于系统级的监听器，它拥有自己的进程，只要存在与之匹配的Broadcast被以Intent的形式发送出来，BroadcastReceiver就会被激活。

和其他的四大组件一样，BroadcastReceiver也有自己独立的声明周期，但是它又和Activity、Service不同。当在系统注册一个BroadcastReceiver之后，每次系统以一个Intent的形式发布Broadcast的时候，系统都会创建与之对应的BroadcastReceiver广播接收者实例，并自动触发它的onReceive()方法，当onReceive()方法被执行完成之后，BroadcastReceiver的实例就会被销毁。

从不同的纬度区分，BroadcastReceiver可以分为不同的类别。

系统广播/非系统广播
全局广播/本地广播
无序广播/有序广播/粘性广播

4.2 基本使用

4.2.1 注册广播

广播的注册分为静态注册和动态注册。静态注册是在Mainfest清单文件中进行注册，比如。

动态注册是在代码中，使用registerReceiver方法代码进行注册，比如。

val br: BroadcastReceiver = MyBroadcastReceiver()

val filter = IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION).apply {

addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED)

}

registerReceiver(br, filter)

4.2.2 发送广播

然后，我们使用sendBroadcast方法发送广播。

Intent().also { intent ->

intent.setAction(“com.example.broadcast.MY_NOTIFICATION”)

intent.putExtra(“data”, “Notice me senpai!”)

sendBroadcast(intent)

}

4.2.3 接收广播

发送广播的时候，我们会添加一个发送的标识，那么接收的时候使用这个标识接收即可。接收广播需要继承BroadcastReceiver，并重写onReceive回调方法接收广播数据。

private const val TAG = “MyBroadcastReceiver”

class MyBroadcastReceiver : BroadcastReceiver() {

override fun onReceive(context: Context, intent: Intent) {

StringBuilder().apply {

append(“Action: ${intent.action}\n”)

append(“URI: ${intent.toUri(Intent.URI_INTENT_SCHEME)}\n”)

toString().also { log ->

Log.d(TAG, log)

Toast.makeText(context, log, Toast.LENGTH_LONG).show()

}

面试题项目地址：Github

5， ContentProvider

ContentProvider是Android四大组件之一，不过平时使用的机会比较少。如果你看过它的底层源码，那么就应该知道ContentProvider是通过Binder进行数据共享。因此，如果我们需要对第三方应用提供数据，可以考虑使用ContentProvider实现。

6，Android View知识点

Android本身的View体系非常庞大的，如果要完全弄懂View的原理是很困难的，我们这里捡一些比较重要的概念来给大家讲解。

6.1 测量流程

Android View本身的绘制流程需要经过measure测量、layout布局、draw绘制三个过程，最终才能够将其绘制出来并展示在用户面前。

首先，我们看一下Android的MeasureSpec，Android的MeasureSpec分为3中模式，分别是EXACTLY、AT_MOST 和 UNSPECIFIED，含义如下。

MeasureSpec.EXACTLY：精确模式，在这种模式下，尺寸的值是多少组件的长或宽就是多少。
MeasureSpec.AT_MOST：最大模式，由父组件能够给出的最大的空间决定。
MeasureSpec.UNSPECIFIED：未指定模式，当前组件可以随便使用空间，不受限制。

6.2 事件分发

Android的事件分发由dispatchTouchEvent、onInterceptTouchEvent和onTouchEvent三个方法构成。

dispatchTouchEvent：方法返回值为true，表示事件被当前视图消费掉；返回为super.dispatchTouchEvent表示继续分发该事件，返回为false表示交给父类的onTouchEvent处理。
onInterceptTouchEvent：方法返回值为true，表示拦截这个事件并交由自身的onTouchEvent方法进行消费；返回false表示不拦截，需要继续传递给子视图。如果return super.onInterceptTouchEvent(ev)，事件拦截分两种情况：即一种是有子View的情况，另一种是没有子View的情况。

如果该View存在子View且点击到了该子View，则不拦截,继续分发给子View 处理，此时相当于return false。如果该View没有子View或者有子View但是没有点击中子View，则交由该View的onTouchEvent响应，此时相当于return true。

onTouchEvent：方法返回值为true表示当前视图可以处理对应的事件；返回值为false表示当前视图不处理这个事件，它会被传递给父视图的onTouchEvent方法进行处理。如果return super.onTouchEvent(ev)，事件处理分为两种情况，即自己消费还是还是向上传递。

在Android系统中，拥有事件传递处理能力的类有以下三种：

Activity：拥有分发和消费两个方法。
ViewGroup：拥有分发、拦截和消费三个方法。
View：拥有分发、消费两个方法。

在事件分发中，有时候会问：ACTION_CANCEL什么时候触发，触摸button然后滑动到外部抬起会触发点击事件吗，再滑动回去抬起会么？

对于这个问题，我们需要明白以下内容：

一般ACTION_CANCEL和ACTION_UP都作为View一段事件处理的结束。如果在父View中拦截ACTION_UP或ACTION_MOVE，在第一次父视图拦截消息的瞬间，父视图指定子视图不接受后续消息了，同时子视图会收到ACTION_CANCEL事件。
如果触摸某个控件，但是又不是在这个控件的区域上抬起，也会出现ACTION_CANCEL。

ViewGroup 默认不拦截任何事件。ViewGroup 的 onInterceptTouchEvent 方法默认返回 false。
View 没有 onInterceptTouchEvent 方法，一旦有点击事件传递给它，onTouchEvent 方法就会被调用。
View 在可点击状态下，onTouchEvent 默认会消耗事件。
ACTION_DOWN 被拦截了，onInterceptTouchEvent 方法执行一次后，就会留下记号（mFirstTouchTarget == null）那么往后的 ACTION_MOVE 和 ACTION_UP 都会拦截。`

6.3 MotionEvent

Android的MotionEvent事件主要有以下几个：

ACTION_DOWN 手指刚接触到屏幕
ACTION_MOVE 手指在屏幕上移动
ACTION_UP 手机从屏幕上松开的一瞬间
ACTION_CANCEL 触摸事件取消

下面是事件的举例：点击屏幕后松开，事件序列为 DOWN -> UP，点击屏幕滑动松开，事件序列为 DOWN -> MOVE -> …> MOVE -> UP。同时，getX/getY 返回相对于当前View左上角的坐标，getRawX/getRawY 返回相对于屏幕左上角的坐标。TouchSlop是系统所能识别出的被认为滑动的最小距离，不同设备值可能不相同，可通过ViewConfiguration.get(getContext()).getScaledTouchSlop() 获取。

6.4 Activity、Window、DecorView之间关系

首先，来看一下Activity中setContentView的源代码。

public void setContentView(@LayoutRes int layoutResID) {

//将xml布局传递到Window当中

getWindow().setContentView(layoutResID);

initWindowDecorActionBar();

}

可以看到， Activity的 setContentView实质是将 View传递到 Window的 setContentView()方法中， Window的 setContenView会在内部调用 installDecor()方法创建 DecorView，代码如下。

public void setContentView(int layoutResID) {

if (mContentParent == null) {

//初始化DecorView以及其内部的content

installDecor();

} else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {

mContentParent.removeAllViews();

}

if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {

…

} else {

//将contentView加载到DecorVoew当中

mLayoutInflater.inflate(layoutResID, mContentParent);

}

…

}

private void installDecor() {

…

if (mDecor == null) {

//实例化DecorView

mDecor = generateDecor(-1);

…

}

} else {

mDecor.setWindow(this);

}

if (mContentParent == null) {

//获取Content

mContentParent = generateLayout(mDecor);

}

…

}

protected DecorView generateDecor(int featureId) {

…

return new DecorView(context, featureId, this, getAttributes());

}

通过 generateDecor()的new一个 DecorView，然后调用 generateLayout()获取 DecorView中 content，最终通过 inflate将 Activity视图添加到 DecorView中的 content中，但此时 DecorView还未被添加到 Window中。添加操作需要借助 ViewRootImpl。

ViewRootImpl的作用是用来衔接 WindowManager和 DecorView，在 Activity被创建后会通过 WindowManager将 DecorView添加到 PhoneWindow中并且创建 ViewRootImpl实例，随后将 DecorView与 ViewRootImpl进行关联，最终通过执行 ViewRootImpl的 performTraversals()开启整个View树的绘制。

6.5 Draw 绘制流程

Android的Draw过程可以分为六个步骤：

首先，绘制View的背景；
如果需要的话，保持canvas的图层，为fading做准备；
然后，绘制View的内容；
接着，绘制View的子View；
如果需要的话，绘制View的fading边缘并恢复图层；
最后，绘制View的装饰(例如滚动条等等)。

涉及到的代码如下：

public void draw(Canvas canvas) {

…

// 步骤一：绘制View的背景

drawBackground(canvas);

…

// 步骤二：如果需要的话，保持canvas的图层，为fading做准备

saveCount = canvas.getSaveCount();

…

canvas.saveLayer(left, top, right, top + length, null, flags);

…

// 步骤三：绘制View的内容

onDraw(canvas);

…

// 步骤四：绘制View的子View

dispatchDraw(canvas);

…

// 步骤五：如果需要的话，绘制View的fading边缘并恢复图层

canvas.drawRect(left, top, right, top + length, p);

…

canvas.restoreToCount(saveCount);

…

// 步骤六：绘制View的装饰(例如滚动条等等)

onDrawForeground(canvas)

}

6.6 Requestlayout，onlayout，onDraw，DrawChild区别与联系

requestLayout()：会导致调用 measure()过程和 layout()过程，将会根据标志位判断是否需要ondraw。
onLayout()：如果该View是ViewGroup对象，需要实现该方法，对每个子视图进行布局。
onDraw()：绘制视图本身 (每个View都需要重载该方法，ViewGroup不需要实现该方法)。
drawChild()：去重新回调每个子视图的draw()方法。

6.7 invalidate() 和 postInvalidate()的区别

invalidate()与postInvalidate()都用于刷新View，主要区别是invalidate()在主线程中调用，若在子线程中使用需要配合handler；而postInvalidate()可在子线程中直接调用。

7，Android进程

7.1 概念

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。

当一个程序第一次启动的时候，Android会启动一个LINUX进程和一个主线程。默认的情况下，所有该程序的组件都将在该进程和线程中运行。同时，Android会为每个应用程序分配一个单独的LINUX用户。Android会尽量保留一个正在运行进程，只在内存资源出现不足时，Android会尝试停止一些进程从而释放足够的资源给其他新的进程使用，也能保证用户正在访问的当前进程有足够的资源去及时地响应用户的事件。

我们可以将一些组件运行在其他进程中，并且可以为任意的进程添加线程。组件运行在哪个进程中是在manifest文件里设置的，其中，，和都有一个process属性来指定该组件运行在哪个进程之中。我们可以设置这个属性，使得每个组件运行在它们自己的进程中，或是几个组件共同享用一个进程，或是不共同享用。元素也有一个process属性，用来指定所有的组件的默认属性。

Android中的所有组件都在指定的进程中的主线程中实例化的，对组件的系统调用也是由主线程发出的。每个实例不会建立新的线程。对系统调用进行响应的方法——例如负责执行用户动作的View.onKeyDown()和组件的生命周期函数——都是运行在这个主线程中的。这意味着当系统调用这个组件时，这个组件不能长时间的阻塞主线程。例如进行网络操作时或是更新UI时，如果运行时间较长，就不能直接在主线程中运行，因为这样会阻塞这个进程中其他的组件，我们可以将这样的组件分配到新建的线程中或是其他的线程中运行。

7.2 进程生命周期

按照生命周期的不同，Android的进程可以分为前台进程、后台进程、可见进程、服务进程和空进程等。

前台进程

前台进程是用户当前正在使用的进程，一些前台进程可以在任何时候都存在，当内存低的时候前台进程也可能被销毁。对于这种情况下，设备会进行内存调度，中止一些前台进程来保持对用户交互的响应。

如果有以下的情形，那么它就是前台进程：

托管用户正在交互的 Activity（已调用 Activity 的 onResume() 方法）
托管某个 Service，后者绑定到用户正在交互的 Activity
托管正在“前台”运行的 Service（服务已调用 startForeground()）
托管正执行一个生命周期回调的 Service（onCreate()、onStart() 或 onDestroy()）
托管正执行其 onReceive() 方法的 BroadcastReceiver

可见进程

可见进程指的是不包含前台组件，但是会在屏幕上显示一个可见的进程。

如果有如下的一种情形，那就是可见进程：

托管不在前台、但仍对用户可见的 Activity（已调用其 onPause() 方法）。例如，如果 re前台 Activity启动了一个对话框，允许在其后显示上一 Activity，则有可能会发生这种情况。
托管绑定到可见（或前台）Activity 的 Service。

服务进程

通过startService() 方法启动的Service，这个Service没有上面的两种进程重要，一般会随着应用的生命周期。

一般来说，使用 startService() 方法启动的服务且不属于上述两个更高类别进程的就是服务进程。

后台进程

包含目前对用户不可见的 Activity 的进程（已调用 Activity 的 onStop() 方法）。通常会有很多后台进程在运行，因此它们会保存在 LRU （最近最少使用）列表中，以确保包含用户最近查看的 Activity 的进程最后一个被终止。

空进程

不含任何活动应用组件的进程。保留这种进程的的唯一目的是用作缓存，以缩短下次在其中运行组件所需的启动时间。为使总体系统资源在进程缓存和底层内核缓存之间保持平衡，系统往往会终止这些进程。

7.3 多进程

首先，进程一般指一个执行单元，在移动设备上就是一个程序或应用，我们在Android中所说的多进程（IPC）一般指一个应用包含多个进程。之所以要使用多进程有两方面原因：某些模块由于特殊的需求要运行在单独的进程；增加应用可用的内存空间。

在Android中开启多进程只有一种方法，就是在AndroidManifest.xml中注册Service、Activity、Receiver、ContentProvider时指定android:process属性，如下所示。

<service

android:name=".MyService"

android:process=":remote">

<activity

android:name=".MyActivity"

android:process=“com.shh.ipctest.remote2”>

可以看到，MyService和MyActivity指定的android:process属性值有所不同，它们的区别如下：

:remote：以:开头是一种简写，系统会在当前进程名前附件当前包名，完整的进程名为：com.shh.ipctest:remote，同时以:开头的进程属于当前应用的私有进程，其它应用的组件不能和它跑在同一进程。
com.shh.ipctest.remote2：这是完整的命名方式，不会附加包名，其它应用如果和该进程的ShareUID、签名相同，则可以和它跑在同一个进程，实现数据共享。

不过，开启多进程会引发如下问题，必须引起注意：

静态成员和单例模式失效
线程同步机制失效
SharedPreferences可靠性降低
Application被多次创建

对于前两个问题，可以这么理解，在Android中，系统会为每个应用或进程分配独立的虚拟机，不同的虚拟机自然占有不同的内存地址空间，所以同一个类的对象会产生不同的副本，导致共享数据失败，必然也不能实现线程的同步。

由于SharedPreferences底层采用读写XML的文件的方式实现，多进程并发的的读写很可能导致数据异常。

Application被多次创建和前两个问题类似，系统在分配多个虚拟机时相当于把同一个应用重新启动多次，必然会导致 Application 多次被创建，为了防止在 Application 中出现无用的重复初始化，可使用进程名来做过滤，只让指定进程的才进行全局初，如下所示。

public class MyApplication extends Application{

@Override

public void onCreate() {

super.onCreate();

String processName = “com.xzh.ipctest”;

if (getPackageName().equals(processName)){

// do some init

}

7.4 多进程通信方式

目前，Android中支持的多进程通信方式主要有以下几种：

AIDL：功能强大，支持进程间一对多的实时并发通信，并可实现 RPC (远程过程调用)。
Messenger：支持一对多的串行实时通信， AIDL 的简化版本。
Bundle：四大组件的进程通信方式，只能传输 Bundle 支持的数据类型。
ContentProvider：强大的数据源访问支持，主要支持 CRUD 操作，一对多的进程间数据共享，例如我们的应用访问系统的通讯录数据。
BroadcastReceiver：即广播，但只能单向通信，接收者只能被动的接收消息。

文件共享：在非高并发情况下共享简单的数据。

Socket：通过网络传输数据。

8，序列化

8.1 Parcelable 与 Serializable

Serializable 使用 I/O 读写存储在硬盘上，而 Parcelable 是直接在内存中读写。
Serializable 会使用反射，序列化和反序列化过程需要大量 I/O 操作， Parcelable 自已实现封送和解封（marshalled &unmarshalled）操作不需要用反射，数据也存放在 Native 内存中，效率要快很多。

8.2 示例

Serializable实例：

import java.io.Serializable;

class serializableObject implements Serializable {

String name;

public serializableObject(String name) {

this.name = name;

}

public String getName() {

return name;

}

Parcelable实例：

import android.os.Parcel;

import android.os.Parcelable;

class parcleObject implements Parcelable {

private String name;

protected parcleObject(Parcel in) {

this.name = in.readString();

}

public parcleObject(String name) {

this.name = name;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public static final Creator CREATOR = new Creator() {

@Override

public parcleObject createFromParcel(Parcel in) {

return new parcleObject(in);

}

@Override

public parcleObject[] newArray(int size) {

return new parcleObject[size];

}

};

@Override

public int describeContents() {

return 0;

}

@Override

public void writeToParcel(Parcel dest, int flags) {

dest.writeString(this.name);

}

使用Parcelable时，一般需要用到以下几个方法：

createFromParcel(Parcel in)：从序列化后的对象中创建原始对象。
newArray(int size)：创建指定长度的原始对象数组。
User(Parcel in) 从序列化后的对象中创建原始对象。
writeToParcel(Parcel dest, int flags)：将当前对象写入序列化结构中，其中 flags 标识有两种值：0 或者 1。为 1 时标识当前对象需要作为返回值返回，不能立即释放资源，几乎所有情况都为 0。
describeContents：返回当前对象的内容描述。如果含有文件描述符，返回 1，否则返回 0，几乎所有情况都返回 0。

9，Window

9.1 基本概念

Window 是一个抽象类，它的具体实现是 PhoneWindow。WindowManager 是外界访问 Window 的入口，Window 的具体实现位于 WindowManagerService 中，WindowManager 和 WindowManagerService 的交互是一个 IPC 过程。Android 中所有的视图都是通过 Window 来呈现，因此 Window 实际是 View 的直接管理者。

依据作用的不同，Window可以分为如下几种：

Application Window：对应着一个 Activity；
Sub Window：不能单独存在，只能附属在父 Window 中，如 Dialog 等；
System Window：需要权限声明，如 Toast 和系统状态栏等；

9.2 内部机制

Window 是一个抽象的概念，每一个 Window 对应着一个 View 和一个 ViewRootImpl。Window 实际是不存在的，它是以 View 的形式存在。对 Window 的访问必须通过 WindowManager，WindowManager 的实现类是 WindowManagerImpl，源码如下：

@Override

public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {

applyDefaultToken(params);

mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);

}

@Override

public void updateViewLayout(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {

applyDefaultToken(params);

mGlobal.updateViewLayout(view, params);

}

@Override

public void removeView(View view) {

mGlobal.removeView(view, false);

}

WindowManagerImpl 没有直接实现 Window 的三大操作，而是全部交给 WindowManagerGlobal 处理，WindowManagerGlobal 以工厂的形式向外提供自己的实例，涉及的代码如下：

// 添加

public void addView(View view, ViewGroup.LayoutParams params,

Display display, Window parentWindow) {

···

// 子 Window 的话需要调整一些布局参数

final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;

if (parentWindow != null) {

parentWindow.adjustLayoutParamsForSubWindow(wparams);

} else {

···

}

ViewRootImpl root;

View panelParentView = null;

synchronized (mLock) {

// 新建一个 ViewRootImpl，并通过其 setView 来更新界面完成 Window 的添加过程

···

root = new ViewRootImpl(view.getContext(), display);

view.setLayoutParams(wparams);

mViews.add(view);

mRoots.add(root);

mParams.add(wparams);

// do this last because it fires off messages to start doing things

try {

root.setView(view, wparams, panelParentView);

} catch (RuntimeException e) {

// BadTokenException or InvalidDisplayException, clean up.

if (index >= 0) {

removeViewLocked(index, true);

}

throw e;

}

// 删除

@UnsupportedAppUsage

public void removeView(View view, boolean immediate) {

···

synchronized (mLock) {

int index = findViewLocked(view, true);

View curView = mRoots.get(index).getView();

removeViewLocked(index, immediate);

···

}

private void removeViewLocked(int index, boolean immediate) {

ViewRootImpl root = mRoots.get(index);

View view = root.getView();

if (view != null) {

InputMethodManager imm = InputMethodManager.getInstance();

if (imm != null) {

imm.windowDismissed(mViews.get(index).getWindowToken());

}

boolean deferred = root.die(immediate);

if (view != null) {

view.assignParent(null);

if (deferred) {

mDyingViews.add(view);

}

// 更新

public void updateViewLayout(View view, ViewGroup.LayoutParams params) {

···

final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;

view.setLayoutParams(wparams);

synchronized (mLock) {

int index = findViewLocked(view, true);

ViewRootImpl root = mRoots.get(index);

mParams.remove(index);

mParams.add(index, wparams);

root.setLayoutParams(wparams, false);

}

10，消息机制

谈Android的消息机制主要就是Handler机制。

10.1 Handler 机制

Handler 有两个主要用途：

安排 Message 和 runnables 在将来的某个时刻执行;
将要在不同于自己的线程上执行的操作排入队列。(在多个线程并发更新UI的同时保证线程安全。)

Android 规定访问 UI 只能在主线程中进行，因为 Android 的 UI 控件不是线程安全的，多线程并发访问会导致 UI 控件处于不可预期的状态。为什么系统不对 UI 控件的访问加上锁机制？缺点有两个：加锁会让 UI 访问的逻辑变得复杂；其次锁机制会降低 UI 访问的效率。如果子线

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》

【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】完整内容开源分享

程访问 UI，那么程序就会抛出异常。为了保证线程安全，ViewRootImpl 对UI操作做了验证，这个验证工作是由 ViewRootImpl的 checkThread 方法完成。

void checkThread() {

if (mThread != Thread.currentThread()) {

throw new CalledFromWrongThreadException(

“Only the original thread that created a view hierarchy can touch its views.”);

}

谈Handler机制时，通常会包含以下三个对象：

Message：Handler 接收和处理的消息对象。
MessageQueue：Message 的队列，先进先出，每一个线程最多可以拥有一个。
Looper：消息泵，是 MessageQueue 的管理者，会不断从 MessageQueue 中取出消息，并将消息分给对应的 Handler 处理，每个线程只有一个 Looper。

Handler 创建的时候会采用当前线程的 Looper 来构造消息循环系统，需要注意的是，线程默认是没有 Looper 的，直接使用 Handler 会报错，如果需要使用 Handler 就必须为线程创建 Looper，因为默认的 UI 主线程，也就是 ActivityThread，ActivityThread 被创建的时候就会初始化 Looper，这也是在主线程中默认可以使用 Handler 的原因。

10.2 工作原理

ThreadLocal ThreadLocal 是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，其他线程则无法获取。Looper、ActivityThread 以及 AMS 中都用到了 ThreadLocal。当不同线程访问同一个ThreadLocal 的 get方法，ThreadLocal 内部会从各自的线程中取出一个数组，然后再从数组中根据当前 ThreadLcoal 的索引去查找对应的value值，源码如下：

public void set(T value) {

Thread t = Thread.currentThread();

ThreadLocalMap map = getMap(t);

if (map != null)

map.set(this, value);

else

createMap(t, value);

}

···

public T get() {

Thread t = Thread.currentThread();

ThreadLocalMap map = getMap(t);

if (map != null) {

ThreadLocalMap.Entry e = map.getEntry(this);

if (e != null) {

@SuppressWarnings(“unchecked”)

T result = (T)e.value;

return result;

}

return setInitialValue();

}

MessageQueue MessageQueue主要包含两个操作：插入和读取。读取操作本身会伴随着删除操作，插入和读取对应的方法分别是 enqueueMessage 和 next。MessageQueue 内部实现并不是用的队列，实际上通过一个单链表的数据结构来维护消息列表。next 方法是一个无限循环的方法，如果消息队列中没有消息，那么 next 方法会一直阻塞。当有新消息到来时，next 方法会放回这条消息并将其从单链表中移除，源码如下。

boolean enqueueMessage(Message msg, long when) {

···

synchronized (this) {

···

msg.markInUse();

msg.when = when;

Message p = mMessages;

boolean needWake;

if (p == null || when == 0 || when < p.when) {

// New head, wake up the event queue if blocked.

msg.next = p;

mMessages = msg;

needWake = mBlocked;

} else {

// Inserted within the middle of the queue. Usually we don’t have to wake

// up the event queue unless there is a barrier at the head of the queue

// and the message is the earliest asynchronous message in the queue.

needWake = mBlocked && p.target == null && msg.isAsynchronous();

Message prev;

for (;

标签：社招,安卓,面试,Window,msg,进程,Android,null,View
来源： https://blog.csdn.net/m0_64382868/article/details/121543630