从源码分析Handler面试问题

这篇具有很好参考价值的文章主要介绍了从源码分析Handler面试问题。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Handler 老生常谈的问题了,非常建议看一下Handler 的源码。刚入行的时候,大佬们就说 阅读源码 是进步很快的方式。

Handler的基本原理

Handler 的 重要组成部分

  • Message 消息
  • MessageQueue 消息队列
  • Lopper 负责处理MessageQueue中的消息

从源码分析Handler面试问题,Android,Framework,面试,面试,android,移动开发,Framework,Handler

消息是如何添加到队列的

对照着上面的大的逻辑图,我们深入一下,看一下,一个消息 是如何被发送到 MessageQueue 又是如何被 Lopper 处理的

handler 发送一个message 的方法如下图所示

从源码分析Handler面试问题,Android,Framework,面试,面试,android,移动开发,Framework,Handler

从源码分析Handler面试问题,Android,Framework,面试,面试,android,移动开发,Framework,Handler

而这些方法最终都会执行 Handler 中的 enqueueMessage 方法,我们看一下 enqueueMessage 方法做了什么

//Handler
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
        long uptimeMillis) {
    //...
    //这里执行MessageQueue的 enqueueMessage
    return queue.enqueueMessage(msg, uptimeMillis);
}

消息队列如何将消息排序

MessageQueue 收到 消息以后,会根据时间进行排列

//MessageQueue
boolean enqueueMessage(Message msg, long when) {
    if (msg.target == null) {
        throw new IllegalArgumentException("Message must have a target.");
    }
    if (msg.isInUse()) {
        throw new IllegalStateException(msg + " This message is already in use.");
    }

    synchronized (this) {
        if (mQuitting) {
            IllegalStateException e = new IllegalStateException(
                    msg.target + " sending message to a Handler on a dead thread");
            Log.w(TAG, e.getMessage(), e);
            msg.recycle();
            return false;
        }

        msg.markInUse();
        msg.when = when;
        //step1 获取头部的message
        Message p = mMessages;
        boolean needWake;
        //step2 头部的message 和 当前的message 对比,如果头部的message 执行时间要 小于 当前message 的时候
        //那么就先执行当前的message
        if (p == null || when == 0 || when < p.when) {
            msg.next = p;
            //头部的message 就变成了 当前的message
            mMessages = msg;
            needWake = mBlocked;
        } else {
            //step3 将当前消息 插入到 中间排队
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            Message prev;
            //根据时间进行排序
            for (;;) {
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    break;
                }
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        }

        // We can assume mPtr != 0 because mQuitting is false.
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

Handler的消息队列在哪创建的

回到创建Handler的地方,他的构造方法

//Handler
public Handler() {
    this(null, false);
}
//Handler
public Handler(Callback callback, boolean async) {
    //...
    //获取当前的looper
    mLooper = Looper.myLooper();
    //...
    //获取looper 的 MessageQueue
    mQueue = mLooper.mQueue;
    //...
}
//Looper
final MessageQueue mQueue;

private Looper(boolean quitAllowed) {
    //在这里创建了一个 MessageQueue
    mQueue = new MessageQueue(quitAllowed);
    //...
}

可以看到 Handler其实是拿着Looper 的MessageQueue当做自己的MessageQueue

Loope有什么作用

消息被有序的添加到了消息队列中,而Looper就是负责将消息从消息队列中取出。当执行Looper的loop()方法,Looper会从消息队列中取出消息,然后交给handler的dispatchMessage去处理消息

//Looper
public static void loop() {
    //...
    for (;;) {
        //从消息队列中获取消息
        Message msg = queue.next(); // might block
        //...
            try {
                //msg.traget 就是Handler 
                //使用 Handler 的  dispatchMessage() 处理消息
                msg.target.dispatchMessage(msg);
                //...
        } catch (Exception exception) {
            //...
        }
        //...
    }
}

一个线程有几个Looper

要想知道有几个Lopper,肯定要先知道Looper在哪里创建。Looper有一个prepare方法

//Looper
public static void prepare() {
    prepare(true);
}

在这里会创建一个新的Looper 并且设置到了ThreadLocal

//Looper
private static void prepare(boolean quitAllowed) {
    //通过 sThreadLocal get 检查是否已经有 looper  
    if (sThreadLocal.get() != null) {
        //如果已经有了 就抛出异常
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    //没有的话 就设置一个新的Looper
    sThreadLocal.set(new Looper(quitAllowed));
}

在ThreadLocal可以看到是以map的形式去保存,保证了一个线程只有一个map,又将looper和ThreadLocal进行绑定

//ThreadLocal
public void set(T value) {
    //获取当前线程
    Thread t = Thread.currentThread();
    //获取 ThreadLocalMap 
    ThreadLocalMap map = getMap(t);
    //有的话 就将当前的 ThreadLocal 和 Looper 绑定在一起,
    if (map != null)
        //set 以后 在上面  sThreadLocal.get() 就不会在为null了
        map.set(this, value);
    else
        //没有的话 创建一个 ThreadLocalMap 在绑定在一起
        createMap(t, value);
}

看到Looper中的 sThreadLocal

//Looper
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

他是一个静态的 final 保证了 一个Looper只有一个 sThreadLocal

最终保证了,一个线程只有一个Looper

主线程什么时候执行preapre

想要使用Looper,肯定需要先prepare 去创建一个Looper,那么主线程如何创建Looper的呢?我们知道 java 程序的入口是 main 方法, 对于Android来说,其实也有一个main 方法,他的位置在 ActivityThread

//ActivityThread
public static void main(String[] args) {
    //...
    //可以看到在这里 程序启动以后,Android 系统帮我们将主线程的Looper prepare
    Looper.prepareMainLooper();

    //...
    //然后帮助我们启动了 loop
    Looper.loop();
    //...
}

Handler内存泄露

Handler为什么会有可能导致内存泄露? 我们知道 内部类会持有外部类的引用,当我们做一个延时任务,延时10S,然后在10S内退出Activity,在我们sendMessage的时候,handler对象被传递给msg 如👇所示,然后被存放在MessageQueue中。在这10S内,即使Activity销毁了,但是引用关系依然被保存在MessageQueue中,那么即使Activity销毁了,他的对象依然不会被GC销毁,因为他依然被引用。就导致内存未被回收。

//Handler
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
        long uptimeMillis) {
    //这里 将 handler 本身的对象 传给 msg 的target
    msg.target = this;
   //...
}

那么如何处理Handler内存泄露呢

1.将Handler改成静态类。原因是因为静态类不会持有外部类的引用 2.继承Handler,将Activity作为弱引用使用 3.在界面退出的时候,调用Handler的removeMessages方法

消息队列没有消息时Handler如何挂起

Looper从MessageQueue中获取message,当获取不到message的时候,会将 nextPollTimeoutMillis置成-1,然后进入下次循环,当执行nativePollOnce方法时候,如果nextPollTimeoutMillis==-1那么就会执行Linux的epoll机制,让线程处于挂起状态,阻塞线程。

//MessageQueue
Message next() {
    for (;;) {
        //step3: nextPollTimeoutMillis == -1 执行native 函数,
        //执行 linux epoll 机制,线程处于等待状态,线程挂起
        nativePollOnce(ptr, nextPollTimeoutMillis);
        synchronized (this) {
            //...
            if (msg != null) {

            } else {
                // step1:如果没有消息  nextPollTimeoutMillis 变成-1
                nextPollTimeoutMillis = -1;
            }

            if (pendingIdleHandlerCount <= 0) {
                // step2:跳出循环 进入下一次循环
                mBlocked = true;
                continue;
            }
        }
    }
}
//Looper
public static void loop() {
    for (;;) {
        //step4:这里也就挂起了
        Message msg = queue.next(); // might block
    }
}

Handler如何退出

使用looper去执行quit方法退出

handler.looper.quit()
//Looper
public void quit() {
    mQueue.quit(false);
}
public void quitSafely() {
    mQueue.quit(true);
}
//MessageQueue
void quit(boolean safe) {
    if (!mQuitAllowed) {
        throw new IllegalStateException("Main thread not allowed to quit.");
    }

    synchronized (this) {
        if (mQuitting) {
            return;
        }
        //step1:将mQuitting 变量变成true
        mQuitting = true;
        //step2:删除所有的消息
        if (safe) {
            removeAllFutureMessagesLocked();
        } else {
            removeAllMessagesLocked();
        }
        //step3:唤醒线程
        nativeWake(mPtr);
    }
}
//MessageQueue
Message next() {
    for (;;) {
        //step4:线程被唤醒。继续执行
        nativePollOnce(ptr, nextPollTimeoutMillis);

        //step5:检查到状态是 true 返回null 出去
        if (mQuitting) {
            dispose();
            return null;
        }
    }
}
//Looper
public static void loop() {
    for (;;) {
        //step6:这里也被唤醒获取到message == null
        Message msg = queue.next(); // might block
        //step7:最终在这里🔚循环
        if (msg == null) {
            return;
        }
    }
}

总结

Looper会先将消息队列中的消息全部清空,然后使用nativeWake的native方法唤醒线程,在上面我们介绍了,当消息队列中没有消息的时候,线程会挂起,处于等待状态,当我们唤醒以后,Looper的loop方法会继续执行下去,然后从MessageQueue中获取到一个null的Message,最终将Looper的loop()方法退出

主线程能够Quit么?

我们知道了 主线程是在ActivityThread的main方法中执行了Looper.prepareMainLooper()创建的Looper

//Looper
@Deprecated
public static void prepareMainLooper() {
    //step1: 注意看这里是一个false
    prepare(false);
}
//Looper
private static void prepare(boolean quitAllowed) {
    //step2:new的Looper传入的是false
    sThreadLocal.set(new Looper(quitAllowed));
}
//Looper
private Looper(boolean quitAllowed) {
    //step3:创建的MessageQueue 传入的也是false
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}
//MessageQueue
MessageQueue(boolean quitAllowed) {
    //step4:将mQuitAllowed 变量变成了false
    mQuitAllowed = quitAllowed;
}
//MessageQueue
void quit(boolean safe) {
    //step5:如果是false 就是主线程 会直接抛出错误
    if (!mQuitAllowed) {
        throw new IllegalStateException("Main thread not allowed to quit.");
    }
}

回头在看一下 Looper的prepare方法,只有主线程可以创建一个不可以quit的MessageQueue,其他线程创建的都是可以quit的

//Looper
//公开方法 prepare 传入的是true
public static void prepare() {
    prepare(true);
}
//私有方法
private static void prepare(boolean quitAllowed) 

//主线程 传入的是false
public static void prepareMainLooper() {
    prepare(false);
}

为什么设计主线程不能被quit

在ActivityThread中,定义了一个H的类,继承了Handler,这个H的handler执行了Android所有的主要事件,比如广播,service,Activity生命周期等都是在这里进行处理,所以不能把主线程quit

//ActivityThread
class H extends Handler {

}

消息如何知道是由哪个Handler发送的?

一个线程可以有多个Handler,想new几个都可以,在我们往MessageQueue中添加消息的时候,会加入一个target标记是哪个handler发送的

//Handler
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
        long uptimeMillis) {
    //step1:在这里 就标记了是哪一个handler 发送的 
    msg.target = this;
    //...
}
//Looper
public static void loop() {
    //...
    for (;;) {
        //...
            try {
                //step2:这里就对应起来是哪一个handler 发送的message 
                msg.target.dispatchMessage(msg);
                //...
        } catch (Exception exception) {
            //...
        }
        //...
}

Handler如何确保线程安全的

//MessageQueue
boolean enqueueMessage(Message msg, long when) {
    //step1:通过加锁的方式,保证了添加消息到消息队列的安全
    synchronized (this) {
    }
}
//MessageQueue
Message next() {
    for (;;) {
        //step2:通过枷锁的方式保证了读取消息的安全
        synchronized (this) {
        }
    }
}

Message如何复用的

看一下我们quit的时候,是怎么从消息队列中清空消息的

//MessageQueue
void quit(boolean safe) {
    synchronized (this) {
        //step1: 清除所有的消息
        if (safe) {
            removeAllFutureMessagesLocked();
        } else {
            removeAllMessagesLocked();
        }
    }
}
//MessageQueue
private void removeAllMessagesLocked() {
    Message p = mMessages;
    while (p != null) {
        Message n = p.next;
        //step2:执行message的方法
        p.recycleUnchecked();
        p = n;
    }
    mMessages = null;
}
//Message
void recycleUnchecked() {
    //step3:将所有的变量全部清空
    flags = FLAG_IN_USE;
    what = 0;
    arg1 = 0;
    arg2 = 0;
    obj = null;
    replyTo = null;
    sendingUid = UID_NONE;
    workSourceUid = UID_NONE;
    when = 0;
    target = null;
    callback = null;
    data = null;

    synchronized (sPoolSync) {
        //默认50个Message
        if (sPoolSize < MAX_POOL_SIZE) {
            //step4:将已经清空状态的Message 放到一个新的链表中
            next = sPool;
            sPool = this;
            sPoolSize++;
        }
    }
}

使用obtain方法会从之前清空状态的链表中取出一个Message去使用,减少创建Message带来的内存消耗。

//Message
public static Message obtain() {
    synchronized (sPoolSync) {
        if (sPool != null) {
            //step5:从已经清空状态的链表中取出一个Message使用
            Message m = sPool;
            sPool = m.next;
            m.next = null;
            m.flags = 0; // clear in-use flag
            sPoolSize--;
            return m;
        }
    }
    return new Message();
}

这种设计模式称为享元设计模式

为什么主线程loop不会导致ANR

首先要知道ANR是怎么出现的,ANR出现的条件有两个

  • 5秒内没有响应输入的事件,触摸反馈等
  • 广播10秒内没有执行完毕

在上面我们分析知道,所有的事件都是由Handler进行分发,在主线程上,发送一个事件,这个事件耗时,将主线程的loop()给卡主,让他只能执行当前任务,不能去处理其他事件就出现了ANR

ANR的本质是由于不能及时处理消息导致的,和他的loop是没有任何关系的

Handler同步屏障

同步屏障概念

啥叫同步屏障,字面意思,就是阻挡同步消息,那么Handler同步屏障是干啥的,没错,你没听错,就是阻挡同步消息,让异步消息过去。阻挡同步消息 这就是同步屏障

在发送消息的时候,mAsynchronous 控制着是否发送的消息是否为异步消息

//Handler
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
        long uptimeMillis) {
    msg.target = this;
    msg.workSourceUid = ThreadLocalWorkSource.getUid();

    //如果是true 则将消息标记为异步消息
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

在Handler构造方法中,控制则是否是异步消息。但是这个方法是hide,正常我们是不能调用的

//Handler
@hide
public Handler(@Nullable Callback callback, boolean async) {
    //这里控制着变量
    mAsynchronous = async;
}

开启同步屏障

那么如何开启同步屏障呢,MessageQueue 中提供了一个 postSyncBarrier 方法 开启同步屏障,

//MessageQueue
public int postSyncBarrier() {
    return postSyncBarrier(SystemClock.uptimeMillis());
}
//MessageQueue
private int postSyncBarrier(long when) {
    // Enqueue a new sync barrier token.
    // We don't need to wake the queue because the purpose of a barrier is to stall it.
    synchronized (this) {
        final int token = mNextBarrierToken++;
        final Message msg = Message.obtain();
        msg.markInUse();
        //👇 注意这里 开启以后没有设置target, 所以Messaged的target 是 null
        msg.when = when;
        msg.arg1 = token;

        Message prev = null;
        Message p = mMessages;
        if (when != 0) {
            while (p != null && p.when <= when) {
                prev = p;
                p = p.next;
            }
        }
        if (prev != null) { // invariant: p == prev.next
            msg.next = p;
            prev.next = msg;
        } else {
            msg.next = p;
            mMessages = msg;
        }
        //返回一个 token 用来取消同步屏障时候使用
        return token;
    }
}

同步屏障工作原理

开启以后,同步屏障如何将异步消息传递出去,将同步消息阻挡下来呢

//MessageQueue
Message next() {
    //...
    //step1:👇 看到这里 一旦收到target == null 表示同步屏障打开了
    if (msg != null && msg.target == null) {
        do {
            prevMsg = msg;
            msg = msg.next;
            //step2:👇 这里就做一个循环, 寻找异步消息
        } while (msg != null && !msg.isAsynchronous());
    }
    //step3:当找到异步消息以后
    if (msg != null) {
        //step4:判断是否到了要执行异步消息的时间
        if (now < msg.when) {
            //如果还没到,就等nextPollTimeoutMillis
            nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
        } else {
            //如果到了执行时间 从链表中移除他
            mBlocked = false;
            if (prevMsg != null) {
                prevMsg.next = msg.next;
            } else {
                mMessages = msg.next;
            }
            msg.next = null;
            if (DEBUG) Log.v(TAG, "Returning message: " + msg);
            msg.markInUse();
            return msg;
        }
    }
}

取消同步屏障

取消同步屏障以后,会唤醒线程,去处理之前未被处理的同步消息。

//MessageQueue
public void removeSyncBarrier(int token) {

    synchronized (this) {
        Message prev = null;
        Message p = mMessages;
        //step1:通过token 寻找设置的同步屏障
        while (p != null && (p.target != null || p.arg1 != token)) {
            prev = p;
            p = p.next;
        }
        if (p == null) {
            throw new IllegalStateException("The specified message queue synchronization "
                    + " barrier token has not been posted or has already been removed.");
        }
        final boolean needWake;
        //step2:从链表中移除
        if (prev != null) {
            prev.next = p.next;
            needWake = false;
        } else {
            mMessages = p.next;
            needWake = mMessages == null || mMessages.target != null;
        }
        //step3:将Message清空
        p.recycleUnchecked();

        if (needWake && !mQuitting) {
            //step4:唤醒线程
            nativeWake(mPtr);
        }
    }
}

GIF演示

下面以一个简单的示例更佳直观的表现,示例分成3中情况

  • 没有启动同步屏障,发送同步消息 发送异步消息
  • 开启同步屏障,发送同步消息 发送异步消息
  • 开启同步屏障,发送同步消息 发送异步消息 在取消同步屏障

没有启动同步屏障,发送同步消息 发送异步消息

可以看到,如果不开启同步屏障,对于Handler 来说 消息都是会被发送出去

开启同步屏障,发送同步消息 发送异步消息

通过对比能够发现,当开启同步屏障以后,发送的同步消息并没有打印,只有异步消息打印了,说明同步屏障确实只能够允许异步消息通过

开启同步屏障,发送同步消息 发送异步消息 在取消同步屏障

当我们移除同步屏障以后,之前没有收到的同步消息,会立马同步过来

演示代码


class HandlerAct : AppCompatActivity() {

    companion object {
        const val TAG = "handler-tag"
        const val MESSAGE_TYPE_SYNC = 0x01
        const val MESSAGE_TYPE_ASYN = 0x02
    }

    private var index = 0

    private lateinit var handler :Handler

    private var token: Int? = null

    @RequiresApi(Build.VERSION_CODES.M)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_handler)
        initHandler()

        linear.addView(MaterialButton(this).apply {
            text = "插入同步屏障"
            setOnClickListener {
                sendSyncBarrier()
            }
        })

        linear.addView(MaterialButton(this).apply {
            text = "移除屏障"
            setOnClickListener {
                removeSyncBarrier()
            }
        })

        linear.addView(MaterialButton(this).apply {
            text = "发送同步消息"
            setOnClickListener {
                sendSyncMessage()
            }
        })

        linear.addView(MaterialButton(this).apply {
            text = "发送异步消息"
            setOnClickListener {
                sendAsynMessage()
            }
        })

    }

    private fun initHandler() {
        Thread {
            Looper.prepare()
            handler = Handler(){
                when(it.what){
                    MESSAGE_TYPE_SYNC -> {
                        Log.i(TAG, "收到同步消息<========== index:${it.arg1}")
                    }
                    MESSAGE_TYPE_ASYN -> {
                        Log.i(TAG, "收到异步消息<========== index:${it.arg1}")
                    }
                }
                true
            }
            Looper.loop()
        }.start()
    }

    private fun sendSyncMessage() {
        index++
        Log.i(TAG, "插入同步消息==========> index:$index")
        val message = Message.obtain()
        message.what = MESSAGE_TYPE_SYNC
        message.arg1 = index
        handler.sendMessageDelayed(message, 1000)
    }

    //往消息队列插入异步消息
    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP_MR1)
    private fun sendAsynMessage() {
        index++
        Log.i(TAG, "插入异步消息==========> index:$index")
        val message = Message.obtain()
        message.what = MESSAGE_TYPE_ASYN
        message.arg1 = index
        message.isAsynchronous = true
        handler.sendMessageDelayed(message, 1000)
    }

    @RequiresApi(Build.VERSION_CODES.M)
    @SuppressLint("DiscouragedPrivateApi")
    fun sendSyncBarrier() {
        try {
            Log.d(TAG, "插入同步屏障")
            val queue: MessageQueue = handler.looper.queue
            val method: Method = MessageQueue::class.java.getDeclaredMethod("postSyncBarrier")
            method.isAccessible = true
            token = method.invoke(queue) as Int
            Log.d(TAG, "token:$token")
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    //移除屏障
    @SuppressLint("DiscouragedPrivateApi")
    @RequiresApi(api = Build.VERSION_CODES.M)
    fun removeSyncBarrier() {
        Log.i(TAG, "移除屏障")
        try {
            val queue: MessageQueue = handler.looper.queue
            val method: Method = MessageQueue::class.java.getDeclaredMethod(
                "removeSyncBarrier",
                Int::class.javaPrimitiveType
            )
            method.isAccessible = true
            method.invoke(queue, token)
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

}

总结

在面试工作中还要许多的小细节需要我们去注意,上面这些面试题目是我在之前网上收集整理的一小部分,由于文档的篇幅长度限制。就在下面用图片展现给大家看了,如果有需要这些面试题参考(内含参考答案):https://qr18.cn/CgxrRy

从源码分析Handler面试问题,Android,Framework,面试,面试,android,移动开发,Framework,Handler文章来源地址https://www.toymoban.com/news/detail-615028.html

到了这里,关于从源码分析Handler面试问题的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Android源码面试宝典】MMKV从使用到原理分析(一)

    去年,我们写过一篇文章,对于android原生提供的key-value存储API SharePreference,进行了从使用到原理的深入分析,同时对其中存在的ANR问题、存取慢等问题,进行了深入的探索、总结。但是之前的文章,我们仅仅指出了问题,没有给大家提供解决方案,也就是说,SharePreference既

    2024年02月01日
    浏览(41)
  • 【Android源码面试宝典】MMKV从使用到原理分析(二)

    上一章节,我们从使用入手,进行了MMKV的简单讲解,我们通过分析简单的运行时日志,从中大概猜到了一些MMKV的代码内部流程,同时,我们也提出了若干的疑问?还是那句话,带着目标(问题)去阅读一篇源码,那么往往收获的知识,更加深入扎实。 本节,我们一起来从源

    2024年01月17日
    浏览(36)
  • Android Framework基础面试篇~

    在Android应用开发面试中,针对Framework的问题是常被考察的。以下是一些常见的Framework金典面试题目及其详解: 1. 什么是Android应用生命周期?你能描述一下它包含哪几个阶段吗? Android应用生命周期指的是应用从启动到关闭的整个过程。 它包括以下四个阶段: onCreate(创建)

    2024年02月10日
    浏览(47)
  • Android源码面试宝典之JobScheduler从使用到原理分析(四)【JobScheduler、StateController 】

    上文,从Job任务的创建,到如何与JSC(JobServiceCotext)关联,到具体任务的绑定、执行进行了源码探索,相信大家到现在为止,对于JobScheduler的庐山真面目,脑海中已经有了些许自己的轮廓。但是,我们也知道,目前为止,仅仅是任务的创建、任务的执行原理我们了解、学习到

    2023年04月15日
    浏览(35)
  • Android源码面试宝典之JobScheduler从使用到原理分析(一)【JobScheduler的使用】

    我们之前总结过HandlerThread、IntentService,http://t.csdn.cn/U7Qzr,知道了,在子线程执行一些定时任务,android已经给我们提供了现成的一些API。但是我们也知道,这些 老的API 随着android的逐步发展,里面的很多漏洞逐渐被开发者们发现。SharePreference的ANR典型问题、HandlerThread的无限

    2024年01月16日
    浏览(31)
  • Android源码面试宝典之JobScheduler从使用到原理分析(二)【JSS的启动】

    上文,我们以IntentService入手,先对JobScheduler进行了简单的实例编码使用。本文开始,我们开始就源码入手,开始深入学习、总结JobScheduler的内部实现原理。 我们从使用代码入手,通过阅读JobScheduler源码,来开始对于其原理,进行深入解读。

    2024年02月02日
    浏览(36)
  • Android FrameWork 知识点与面试题整合~

    1.如何对 Android 应用进行性能分析 android 性能主要之响应速度 和UI刷新速度。 首先从函数的耗时来说,有一个工具TraceView 这是androidsdk自带的工作,用于测量函数耗时的。 UI布局的分析,可以有2块,一块就是Hierarchy Viewer 可以看到View的布局层次,以及每个View刷新加载的时间。

    2023年04月14日
    浏览(39)
  • Android Framework分析SystemServer进程

    SystemServer进程是Android系统的核心进程,运行在Android系统启动后,负责管理和加载系统服务。本文将介绍SystemServer进程的详细结构和工作原理,并使用代码注释的方式阐述其关键部分代码。 结构: SystemServer进程的核心是SystemServer类,它是Android系统启动后的第一个Java进程。

    2024年02月09日
    浏览(50)
  • Android Framework | AOSP源码下载及编译指南(基于Android13)

    AOSP(Android Open Source Project)是Android操作系统的开源项目,通过下载和编译AOSP源码,您可以获得原始的Android系统,并进行定制和开发。本教程将向您介绍如何下载AOSP源码并进行编译的步骤。 如何只是浏览查看AOSP源码,则没必要下载源码,可以使用google提供的Code Search工具进

    2024年01月16日
    浏览(60)
  • 【Android12】Android Framework系列---Adb和PMS安装apk源码流程

    通过adb install命令可以将apk安装到Android系统(注意:特定类型的apk,比如persist类型是无法通过adb安装的) 下述命令中adb解析install命令,并调用Android PackageManagerService进行apk安装。 基于Android12,分析从adb install到 PakcageManagerService安装apk的流程。 adb install命令的源码实现 Andro

    2024年01月22日
    浏览(62)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包