最后
分享一些资料给大家，我觉得这些都是很有用的东西，大家也可以跟着来学习，查漏补缺。
《Java高级面试》
《Java高级架构知识》
《算法知识》
BroadcastQueue.java
final void processNextBroadcast(boolean fromMsg) {
synchronized (mService) {
processNextBroadcastLocked(fromMsg, false);
}
}
final void processNextBroadcastLocked(boolean fromMsg, boolean skipOomAdj){
while (mParallelBroadcasts.size() > 0) {
r = mParallelBroadcasts.remove(0);
final int N = r.receivers.size();
//依次取出分发
for (int i=0; i<N; i++) {
Object target = r.receivers.get(i);
//调用
deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false, i);
}
}
}
private void deliverToRegisteredReceiverLocked(BroadcastRecord r,
BroadcastFilter filter, boolean ordered, int index) {
··· //分发广播到客户端
performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
new Intent(r.intent), r.resultCode, r.resultData,
r.resultExtras, r.ordered, r.initialSticky, r.userId);
····
}
void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver,
Intent intent, int resultCode, String data, Bundle extras,
boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
// Send the intent to the receiver asynchronously using one-way binder calls.
//判断应是否为空
if (app != null) {
if (app.thread != null) {
//通知客户端分发广播，Binder采用 oneway 异步 应用端会自动串行化
app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
data, extras, ordered, sticky, sendingUser, app.repProcState);
}
} else {
receiver.performReceive(intent, resultCode, data, extras, ordered,
sticky, sendingUser);
}
}
AMS端的app.thread.scheduleRegisteredReceiver()，会调用到注册时注册的InnerReceiver的performReceive方法
ActivityThread.java
public void scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent,
int resultCode, String dataStr, Bundle extras, boolean ordered,
boolean sticky, int sendingUser, int processState) throws RemoteException {
updateProcessState(processState, false);
//1
receiver.performReceive(intent, resultCode, dataStr, extras, ordered,
sticky, sendingUser);
}
InnerReceiver.java
public void performReceive(Intent intent, int resultCode, String data,
Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
final LoadedApk.ReceiverDispatcher rd;
···
if (rd != null) {
//调用LoadedApk.ReceiverDispatcher的performReceive
rd.performReceive(intent, resultCode, data, extras,
ordered, sticky, sendingUser);
···
}
}
···
LoadedApk.ReceiverDispatcher.java
public void performReceive(Intent intent, int resultCode, String data,
Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
final Args args = new Args(intent, resultCode, data, extras, ordered,
sticky, sendingUser);
···
//向ActivityThread发送一个Runnable
if (intent == null || !mActivityThread.post(args.getRunnable())) {
}
}
Args.java
public final Runnable getRunnable() {
return () -> {
final BroadcastReceiver receiver = mReceiver;
final boolean ordered = mOrdered;
=
final IActivityManager mgr = ActivityManager.getService();
···
receiver.setPendingResult(this);
//这里触发了BoradcastReciever回调
receiver.onReceive(mContext, intent);
···
};
}
=========================================================================
1、首先动态注册BroadcastReceiver到AMS，将他们存储在一个Map中，Map的key是IIntentReceiver用于回调注册端，value是一个ReceiverList
2、发送这发送Intent到AMS，筛选出匹配的ReceiverList，遍历通知注册端
=======================================================================================
PackageParser.java
private boolean parseBaseApplication(Package owner, Resources res,
XmlResourceParser parser, int flags, String[] outError){
else if (tagName.equals(“receiver”)) {
Activity a = parseActivity(owner, res, parser, flags, outError, cachedArgs,
true, false);
owner.receivers.add(a);
}
}
1、将receiver解析成一个Activity（这个Activity表示的是一个组件）对象，添加到receivers的列表中，receivers是一个ArrayList
============================================================================
最后会调用到
ContextImpl.java
public void sendBroadcast(Intent intent) {
warnIfCallingFromSystemProcess();
String resolvedType = intent.resolveTypeIfNeeded(getContentResolver());
intent.prepareToLeaveProcess(this);
ActivityManager.getService().broadcastIntent(
mMainThread.getApplicationThread(), intent, resolvedType, null,
Activity.RESULT_OK, null, null, null, AppOpsManager.OP_NONE, null, false, false,
getUserId());
}
ActivityManagerService.java
public final int broadcastIntent(IApplicationThread caller,
Intent intent, String resolvedType, IIntentReceiver resultTo,
int resultCode, String resultData, Bundle resultExtras,
String[] requiredPermissions, int appOp, Bundle bOptions,
boolean serialized, boolean sticky, int userId) {
···
int res = broadcastIntentLocked(callerApp,
callerApp != null ? callerApp.info.packageName : null,
intent, resolvedType, resultTo, resultCode, resultData, resultExtras,
requiredPermissions, appOp, bOptions, serialized, sticky,
callingPid, callingUid, userId);
···
}
}
final int broadcastIntentLocked(ProcessRecord callerApp,
String callerPackage, Intent intent, String resolvedType,
IIntentReceiver resultTo, int resultCode, String resultData,
Bundle resultExtras, String[] requiredPermissions, int appOp, Bundle bOptions,
boolean ordered, boolean sticky, int callingPid, int callingUid, int userId){
···
//获取接收静态广播
receivers = collectReceiverComponents(intent, resolvedType, callingUid, users);
//通过Intent查找能接受的动态广播
registeredReceivers = mReceiverResolver.queryIntent(intent,
resolvedType, false /defaultOnly/, userId);
int NR = registeredReceivers != null ? registeredReceivers.size() : 0;
if (!ordered && NR > 0) {
//处理动态广播，添加到并行分发队列，OneWay发送binder处理是串行的
}
//给没有处理完的动态receiver（order是true），跟静态receiver合并到一起
if ((receivers != null && receivers.size() > 0){
//处理剩下的receiver。加到串行分发队列
//获取queue
BroadcastQueue queue = broadcastQueueForIntent(intent);
BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp,
callerPackage, callingPid, callingUid, callerInstantApp, resolvedType,
requiredPermissions, appOp, brOptions, receivers, resultTo, resultCode,
resultData, resultExtras, ordered, sticky, false, userId);
//添加到串行分发queue
queue.enqueueOrderedBroadcastLocked®;
//处理分发
queue.scheduleBroadcastsLocked();
}
return ActivityManager.BROADCAST_SUCCESS;
}
queue.scheduleBroadcastsLocked();会发送BROADCAST_INTENT_MSG，调用processNextBroadcast(true);
BroadcastQueue.java
final void processNextBroadcast(boolean fromMsg) {
synchronized (mService) {
processNextBroadcastLocked(fromMsg, false);
}
}
final void processNextBroadcastLocked(boolean fromMsg, boolean skipOomAdj){
while (mParallelBroadcasts.size() > 0) {
r = mParallelBroadcasts.remove(0);
final int N = r.receivers.size()
for (int i=0; i<N; i++) {
Object target = r.receivers.get(i);
//先并行分发，然后接下来分发串行广播
deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false, i);
}
}
//如果有pedding广播，先直接返回，这个广播在等待应用进程启动
//如果当前广播分发超时了，废弃这个广播，处理下一个广播
broadcastTimeoutLocked(false);
//如果没有超时，并且在分发中，就先返回。什么也不做
//如果当前的广播已经分发完一个receiver，就继续分发下一个receiver
//如果这个receiver是动态注册的receiver就直接分发
//如果这个receiver是静态注册的receiver，先看进程启动没有
//如果进程启动了，就直接分发
processCurBroadcastLocked(r, app, skipOomAdj);
//没启动的话就先启动进程，然后给广播标记为pedding
//进程启动后attachApplication时继续处理这个pending的广播
}
BroadcastQueue.java
//处理超时
final void broadcastTimeoutLocked(boolean fromMsg) {
BroadcastRecord r = mOrderedBroadcasts.get(0);
Object curReceiver = r.receivers.get(r.nextReceiver-1);
//找到当前分发receiver对应的进程
if (mPendingBroadcast == r) {
mPendingBroadcast = null;
}
// Move on to the next receiver.
finishReceiverLocked(r, r.resultCode, r.resultData,
r.resultExtras, r.resultAbort, false);
//发送消息处理下一个receiver
scheduleBroadcastsLocked();
if (!debugging && anrMessage != null) {
// Post the ANR to the handler since we do not want to process ANRs while
// potentially holding our lock.
//超时显示ANR
mHandler.post(new AppNotResponding(app, anrMessage));
}
}
BroadcastQueue.java
//接收进程存在，通知接收进程
private final void processCurBroadcastLocked(BroadcastRecord r,
ProcessRecord app, boolean skipOomAdj) throws RemoteException {
···
app.thread.scheduleReceiver(new Intent(r.intent), r.curReceiver,
mService.compatibilityInfoForPackageLocked(r.curReceiver.applicationInfo),
r.resultCode, r.resultData, r.resultExtras, r.ordered, r.userId,
app.repProcState);
···
}
5.4.1 进程存在直接处理
ActivityThread.java
public final void scheduleReceiver(Intent intent, ActivityInfo info,
CompatibilityInfo compatInfo, int resultCode, String data, Bundle extras,
boolean sync, int sendingUser, int processState) {
updateProcessState(processState, false);
ReceiverData r = new ReceiverData(intent, resultCode, data, extras,
sync, false, mAppThread.asBinder(), sendingUser);
r.info = info;
r.compatInfo = compatInfo;
sendMessage(H.RECEIVER, r);
}
private void handleReceiver(ReceiverData data) {
sCurrentBroadcastIntent.set(data.intent);
receiver.setPendingResult(data);
//执行BroadcastReceiver
//依据Application的Context创建的ContextWarpper，目的是不允许BroadcastReceiver在注册接收器，也不允许启动服务
receiver.onReceive(context.getReceiverRestrictedContext(),
data.intent);
if (receiver.getPendingResult() != null) {
//通知AMS分发结束
data.finish();
}
}
BroadcastReceiver.java
public final void finish() {
if (mType == TYPE_COMPONENT) {
final IActivityManager mgr = ActivityManager.getService();
if (QueuedWork.hasPendingWork()) {
QueuedWork.queue(new Runnable() {
@Override public void run() {
if (ActivityThread.DEBUG_BROADCAST) Slog.i(ActivityThread.TAG,
"Finishing broadcast after work to component " + mToken);
sendFinished(mgr);
}
}, false);
} else {
sendFinished(mgr);
}
} else if (mOrderedHint && mType != TYPE_UNREGISTERED) {
final IActivityManager mgr = ActivityManager.getService();
sendFinished(mgr);
}
}
public void sendFinished(IActivityManager am) {
//通知AMS分发结束
am.finishReceiver(mToken, 0, null, null, false, mFlags);
}
5.4.2 进程不存在
在attachApplication中处理PenndingReceiver
ActivityManagerService.java
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid, int callingUid, long startSeq) {
···
sendPendingBroadcastsLocked(app);
···
}
boolean sendPendingBroadcastsLocked(ProcessRecord app) {
boolean didSomething = false;
for (BroadcastQueue queue : mBroadcastQueues) {
didSomething |= queue.sendPendingBroadcastsLocked(app);
}
return didSomething;
}
BroadcastQueue.java
public boolean sendPendingBroadcastsLocked(ProcessRecord app) {
···
processCurBroadcastLocked(br, app, false);
···
}
private final void processCurBroadcastLocked(BroadcastRecord r,
ProcessRecord app, boolean skipOomAdj) throws RemoteException {
···
//通知客户端调用接收方法
app.thread.scheduleReceiver(new Intent(r.intent), r.curReceiver,
mService.compatibilityInfoForPackageLocked(r.curReceiver.applicationInfo),
r.resultCode, r.resultData, r.resultExtras, r.ordered, r.userId,
app.repProcState);
···
}
app.thread.scheduleReceiver，发送RECEIVER消息给ActivityThread，调用到ActivityThread的handleReceiver
ActivityThread.java
private void handleReceiver(ReceiverData data) {
···
sCurrentBroadcastIntent.set(data.intent);
receiver.setPendingResult(data);
//回调BroadcastReceiver
receiver.onReceive(context.getReceiverRestrictedContext(),
data.intent);
} catch (Exception e) {
data.sendFinished(mgr);
} finally {
sCurrentBroadcastIntent.set(null);
}
if (receiver.getPendingResult() != null) {
//通知分发结束
总结：绘上一张Kakfa架构思维大纲脑图（xmind）
其实关于Kafka，能问的问题实在是太多了，扒了几天，最终筛选出44问：基础篇17问、进阶篇15问、高级篇12问，个个直戳痛点，不知道如果你不着急看答案，又能答出几个呢？
若是对Kafka的知识还回忆不起来，不妨先看我手绘的知识总结脑图（xmind不能上传，文章里用的是图片版）进行整体架构的梳理
梳理了知识，刷完了面试，如若你还想进一步的深入学习解读kafka以及源码，那么接下来的这份《手写“kafka”》将会是个不错的选择。
-
Kafka入门
-
为什么选择Kafka
-
Kafka的安装、管理和配置
-
Kafka的集群
-
第一个Kafka程序
-
Kafka的生产者
-
Kafka的消费者
-
深入理解Kafka
-
可靠的数据传递
-
Spring和Kafka的整合
-
SpringBoot和Kafka的整合
-
Kafka实战之削峰填谷
-
数据管道和流式处理(了解即可)
inished(mgr);
} finally {
sCurrentBroadcastIntent.set(null);
}
if (receiver.getPendingResult() != null) {
//通知分发结束
总结：绘上一张Kakfa架构思维大纲脑图（xmind）
[外链图片转存中…(img-kUCL5rCP-1715815041504)]
其实关于Kafka，能问的问题实在是太多了，扒了几天，最终筛选出44问：基础篇17问、进阶篇15问、高级篇12问，个个直戳痛点，不知道如果你不着急看答案，又能答出几个呢？
若是对Kafka的知识还回忆不起来，不妨先看我手绘的知识总结脑图（xmind不能上传，文章里用的是图片版）进行整体架构的梳理
梳理了知识，刷完了面试，如若你还想进一步的深入学习解读kafka以及源码，那么接下来的这份《手写“kafka”》将会是个不错的选择。
-
Kafka入门
-
为什么选择Kafka
-
Kafka的安装、管理和配置
-
Kafka的集群
-
第一个Kafka程序
-
Kafka的生产者
-
Kafka的消费者
-
深入理解Kafka
-
可靠的数据传递
-
Spring和Kafka的整合
-
SpringBoot和Kafka的整合
-
Kafka实战之削峰填谷
-
数据管道和流式处理(了解即可)
[外链图片转存中…(img-JOh785nG-1715815041505)]
[外链图片转存中…(img-OlurZrnF-1715815041505)]
628
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
