Andrid中的Looper，Handler，Message研究

Looper.loop();

}

}

加入handler后的效果如下图：

一个线程可以有多个Handler，但是只能有一个Looper！

Handler发送消息

创建Handler后可以使用 [post(Runnable)]( ),   [postAtTime(Runnable, long)]( ),  [postDelayed(Runnable, long)]( ),  [sendEmptyMessage(int)]( ),   [sendMessage(Message)]( ), [sendMessageAtTime(Message, long)]( ) 和 [sendMessageDelayed(Message, long)]( )这些方法向MessageQueue上发送消息。光看这些API你可能会觉得handler能发两种消息，一种是Runnable对象，一种是message对象，其实发出的Runnable对象最后也被封装成message对象了，见源码：

// 此方法用于向关联的MQ上发送Runnable对象，它的run方法将在handler关联的looper线程中执行

public final boolean post(Runnable r)

{

// 注意getPostMessage®将runnable封装成message

return  sendMessageDelayed(getPostMessage®, 0);

}

private final Message getPostMessage(Runnable r) {

Message m = Message.obtain();  //得到空的message

m.callback = r;  //将runnable设为message的callback，

return m;

}

public boolean sendMessageAtTime(Message msg, long uptimeMillis)

{

boolean sent = false;

MessageQueue queue = mQueue;

if (queue != null) {

msg.target = this;  // message的target必须设为该handler！

sent = queue.enqueueMessage(msg, uptimeMillis);

}

else {

RuntimeException e = new RuntimeException(

this + " sendMessageAtTime() called with no mQueue");

Log.w(“Looper”, e.getMessage(), e);

}

return sent;

}

通过Handler发出的message的特点：

1. message.target为该handler对象，这确保了looper执行到该message时能找到处理它的handler，即loop()方法中的关键代码

msg.target.dispatchMessage(msg);

2. post发出的message，其callback为Runnable对象

Handler处理消息

消息的处理是通过核心方法dispatchMessage(Message msg)与handleMessage(Message msg)方法完成的，见源码

// 处理消息，该方法由looper调用

public void dispatchMessage(Message msg) {

if (msg.callback != null) {

// 如果message设置了callback，即runnable消息，处理callback！

handleCallback(msg);

} else {

// 如果handler本身设置了callback，则执行callback

if (mCallback != null) {

/* 这种方法允许让activity等来实现Handler.Callback接口，避免了自己编写handler重写handleMessage方法。见http://alex-yang-xiansoftware-com.iteye.com/blog/850865 */

if (mCallback.handleMessage(msg)) {

return;

}

}

// 如果message没有callback，则调用handler的钩子方法handleMessage

handleMessage(msg);

}

}

// 处理runnable消息

private final void handleCallback(Message message) {

message.callback.run();  //直接调用run方法！

}

// 由子类实现的钩子方法

public void handleMessage(Message msg) {

}

可以看到，除了handleMessage(Message msg)和Runnable对象的run方法由开发者实现外（实现具体逻辑），handler的内部工作机制对开发者是透明的。

Handler的用处

Handler拥有下面两个重要的特点：

1.handler可以在任意线程发送消息，这些消息会被添加到关联的MessageQueue上。

2.handler是在它关联的looper线程中处理消息的。

Android的主线程也是一个Looper线程，在其中创建的handler默认将关联主线程MessageQueue。因此，利用handler的常用场景就是在activity中创建handler并将其引用传递给你的线程，你的线程执行完任务后使用handler发送消息通知Activity更新UI。(过程如图)

下面给出sample代码，仅供参考：

public class TestDriverActivity extends Activity {

private TextView textview;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

textview = (TextView) findViewById(R.id.textview);

// 创建并启动工作线程

Thread workerThread = new Thread(new SampleTask(new MyHandler()));

workerThread.start();

}

public void appendText(String msg) {

textview.setText(textview.getText() + “\n” + msg);

}

class MyHandler extends Handler {

@Override

public void handleMessage(Message msg) {

String result = msg.getData().getString(“message”);

// 更新UI

appendText(result);

}

}

}

public class SampleTask implements Runnable {

private static final String TAG = SampleTask.class.getSimpleName();

Handler handler;

public SampleTask(Handler handler) {

super();

this.handler = handler;

}

@Override

public void run() {

try {  // 模拟执行某项任务，下载等

Thread.sleep(5000);

// 任务完成后通知activity更新UI

Message msg = prepareMessage(“task completed!”);

// message将被添加到主线程的MQ中

handler.sendMessage(msg);

} catch (InterruptedException e) {

Log.d(TAG, “interrupted!”);

}

}

private Message prepareMessage(String str) {

Message result = handler.obtainMessage();

Bundle data = new Bundle();

data.putString(“message”, str);

result.setData(data);

return result;

}

}

当然，handler能做的远远不仅如此，由于它能post Runnable对象，它还能与Looper配合实现经典的Pipeline Thread(流水线线程)模式。

整个消息处理机制中，message封装了任务携带的信息和处理该任务的handler。message的用法比较简单，有几点需要注意：

1. 尽管Message有public的默认构造方法，但是应该通过Message.obtain()来从消息池中获得空消息对象，以节省资源。

2. 如果你的message只需要携带简单的int信息，请优先使用Message.arg1和Message.arg2来传递信息，这比用Bundle更省内存；

3. 擅用message.what来标识信息，以便用不同方式处理message。

=============================================================================

下面是转载的一篇介绍消息机制的整个流程：

每一个handler其实都绑定了一个线程（Thread）和消息队列（MessageQueue），消息队列中存放的是一堆待处理的消息，Looper通过一个loop方法不断从消息队列中获取到消息（Message）（先进先出的方式），执行消息队列的出队方法，然后该消息会通过自身绑定target（其实是一个handler对象），分发处理携带的消息（dispatchMessage）。消息处理完成之后，该消息会被回收（recycle），回到消息池中。而handler的sendMessage方法其实会调用消息队列的入队方法（enqueueMessage），将包装好的消息加到消息队列中，再次循环。这其实就是android下的消息机制。本文将试图从源码的角度分析这一流程。

首先介绍Handler，Looper，MessageQueue，Message四个概念：

Message：消息，其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理。

Handler：处理者，负责Message的发送及处理。使用Handler时，需要实现handleMessage(Message msg)方法来对特定的Message进行处理，例如更新UI等。

MessageQueue：消息队列，用来存放Handler发送过来的消息，并按照FIFO规则执行。当然，存放Message并非实际意义的保存，而是将Message以链表的方式串联起来的，等待Looper的抽取。

Looper：消息泵，不断地从MessageQueue中抽取Message执行。因此，一个MessageQueue需要一个Looper。

-------------------------------------

注：一个线程默认是没有消息队列的，如果我们要使用handler，必须指定Looper,Looper内部会创建MessageQueue。其中比较特殊的是UI线程提供了默认的Looper，我们不需要为其指定Looper。如果是其他线程，我们必须显式调用Looper.prepare和Looper.loop方法创建Looper并使其运转起来。

[java]  view plain copy

1. class LooperThread extends Thread {

2. public Handler mHandler;

3. public void run() {

4. Looper.prepare();

5. mHandler = new Handler() {

6. public void handleMessage(Message msg) {

7. // process incoming messages here

8. }

9. };

10. Looper.loop();

11. }

12. }

----------------------

下面我们将从Handler调用post或者sendMessage方法开始，跟踪源码进行分析，从而了解整个消息机制的运作过程。

我们在调用sendMessage方法时，需要提供一个Message对象，Message对象用于封装一个消息，我们通过查看源码观察下该类的成员变量:

[java]  view plain copy

1. public final class Message implements Parcelable {

2. public int what;

3. public int arg1;

4. public int arg2;

5. public Object obj;

6. long when;

7. Bundle data;

8. Handler target;

9. Runnable callback;

10. // sometimes we store linked lists of these things

11. Message next;

12. private static final Object sPoolSync = new Object();

13. private static Message sPool;

14. private static int sPoolSize = 0;

15. private static final int MAX_POOL_SIZE = 50;

16. … …

四个公有变量相信大家都不陌生，这里就不再介绍了。我们看到Message还有一些成员变量，比如说target，这是个Handler对象，target可以通过set方法或者obtainMessage等方式设置，一旦设置了T arget，这个message就被绑定到一个具体的handler上了，然后message内部即可调用sendToTarget方法将message交给绑定的Handler进行处理，内部也调用的是sendMessage：

[java]  view plain copy

1. public void sendToTarget() {

2. target.sendMessage(this);

3. }

callback对象是Runnable类型的，这个也比较好理解，因为我们的handler除了可以处理message之外，还可以通过Post方式将Runnable加入队列，进行处理。这个执行流程我们放在后面介绍。

我们还看到了一个Message类型的next，这个成员变量持有了下一个Message的引用，众多Message就是通过这种方式形成一个链表，也就是所谓的消息池，我们看到消息池默认的容量为0(sPoolSize ​),池的最大容量为50。Message的obtain及其重载形式每次调用都会从池中取出一个Message，如果不存在就new一个出来。

[java]  view plain copy

1. public static Message obtain() {

2. synchronized (sPoolSync) {

3. if (sPool != null) {

4. Message m = sPool;

5. sPool = m.next;

6. m.next = null;

7. sPoolSize–;

8. return m;

9. }

10. }

11. return new Message();

12. }

recycle方法又会将用完的Message回收：

[java]  view plain copy

1. public void recycle() {

2. clearForRecycle();

3. synchronized (sPoolSync) {

4. if (sPoolSize < MAX_POOL_SIZE) {

5. next = sPool;

6. sPool = this;

7. sPoolSize++;

8. }

9. }

10. }

现在假设我们的消息已经封装好了，下一步必然就是发送消息了。通过调用Handler的sendMessage方法可以发送一条消息。

[java]  view plain copy

1. public final boolean sendMessage(Message msg)

2. {

3. return sendMessageDelayed(msg, 0);

4. }

sendMessage方法调用了sendMessageDelayed方法，延时设为0，继续跟源码：

[java]  view plain copy

1. public final boolean sendMessageDelayed(Message msg, long delayMillis)

2. {

3. if (delayMillis < 0) {

4. delayMillis = 0;

5. }

6. return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);

7. }

先是判断延时参数的合法性，然后调用了sendMessageAtTime方法，果断跟进去看看：

[java]  view plain copy

1. public boolean sendMessageAtTime(Message msg, long uptimeMillis) {

2. MessageQueue queue = mQueue;

3. if (queue == null) {

4. RuntimeException e = new RuntimeException(

5. this + " sendMessageAtTime() called with no mQueue");

6. Log.w(“Looper”, e.getMessage(), e);

7. return false;

8. }

9. return enqueueMessage(queue, msg, uptimeMillis);

10. }

跟到这一步，我们发现了一个没见过的变量，mQueue，查看该变量定义：

[java]  view plain copy

1. …

2. final MessageQueue mQueue;

3. final Looper mLooper;

4. final Callback mCallback;

5. …

原来mQueue是一个消息队列，那么消息队列是怎么初始化的呢？我们找到Handler的一个构造器：

[java]  view plain copy

1. public Handler(Callback callback, boolean async) {

2. … …

3. mLooper = Looper.myLooper();

4. if (mLooper == null) {

5. throw new RuntimeException(

6. “Can’t create handler inside thread that has not called Looper.prepare()”);

7. }

8. mQueue = mLooper.mQueue;

9. mCallback = callback;

10. mAsynchronous = async;

11. }

原来mQueue是Looper的成员变量，这个构造器通过Looper.myLooper方法返回了一个与当前线程绑定的Looper对象，进而获取到与Looper绑定的MessageQueue。这是Looper的构造器：

[java]  view plain copy

1. private Looper(boolean quitAllowed) {

2. mQueue = new MessageQueue(quitAllowed);

3. mRun = true;

4. mThread = Thread.currentThread();

5. }

既然我们知道了mQueue的来历，那么我们继续随着上面的思路跟进吧！刚才我们通过跟踪sendMessage源码发现内部最终调用了sendMessageAtTime方法，而这个方法又调用了enqueueMessage方法，从名字上能看出，该方法是将消息出队的方法，等等。。消息出队不应该是消息队列的方法么？怎么Handler也有？别急，我们查看enqueueMessage方法源码：

[java]  view plain copy

1. private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {

2. msg.target = this;//我觉得这里应该判断target是否已经存在，如果存在就没必要设置了吧？

3. if (mAsynchronous) {

4. msg.setAsynchronous(true);

5. }

6. return queue.enqueueMessage(msg, uptimeMillis);

7. }

这下原因显而易见了，handler的入队方法其实调用的是消息队列的入队方法。

下面我们来到MessageQueue源码，查找到enqueueMessage方法：

[java]  view plain copy

1. final boolean enqueueMessage(Message msg, long when) {

2. if (msg.isInUse()) {//消息是否正在使用

3. throw new AndroidRuntimeException(msg + " This message is already in use.");

4. }

5. if (msg.target == null) {//是否绑定handler

6. throw new AndroidRuntimeException(“Message must have a target.”);

7. }

8. boolean needWake;

9. synchronized (this) {

10. if (mQuiting) {

11. RuntimeException e = new RuntimeException(

12. msg.target + " sending message to a Handler on a dead thread");

13. Log.w(“MessageQueue”, e.getMessage(), e);

14. return false;

15. }

16. msg.when = when;

17. Message p = mMessages;

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

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

20. msg.next = p;

21. mMessages = msg;

22. needWake = mBlocked;

23. } else {

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

25. Message prev;

26. for (;😉 {

27. prev = p;

28. p = p.next;

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

30. break;

31. }

32. if (needWake && p.isAsynchronous()) {

33. needWake = false;

34. }

35. }

36. msg.next = p; // invariant: p == prev.next

37. prev.next = msg;

38. }

39. }

40. if (needWake) {

41. nativeWake(mPtr);

42. }

43. return true;

44. }

跟到这里终于明白了，这个MessageQueue是通过mMessages变量来记录当前待处理的消息，通过Mesage的发送的时间进行排序（调用msg.next）。

到这里整个入队操作就分析完了，通过这一系列的操作，handler将消息发送给了消息队列。到这里消息只是不断被加到消息队列中，我们并没有取出消息。那么Handler的handMessage方法又是怎么被调用的呢？？带着这个疑问，我们来研究下Looper，消息泵，既然是泵，之所以叫泵，是因为它可以从消息队列中取出消息！之前说过，要在线程中使用Handler，必须调用Looper的prepare方法创建Looper对象，然后调用loop方法让消息队列运作起来。那么，这个loop方法是关键，我们查看该方法源码：

[java]  view plain copy

1. public static void loop() {

2. final Looper me = myLooper();

3. if (me == null) {

4. throw new RuntimeException(“No Looper; Looper.prepare() wasn’t called on this thread.”);

5. }

6. final MessageQueue queue = me.mQueue;

7. Binder.clearCallingIdentity();

8. … …

9. for (;😉 {

10. Message msg = queue.next(); // might block

11. if (msg == null) {

12. return;

13. }

14. … …

15. msg.target.dispatchMessage(msg);

16. … …

17. msg.recycle();

18. }

19. }

这个方法首先获取到消息队列的一个引用，然后在一个死循环中反复调用消息队列的出队方法（next）获取到下一个待处理的消息的引用，然后调用该消息所绑定的handler的dispatchMessage方法分发消息，最后将该消息回收。我们跟踪Handler的 dispatchMessage方法：

[java]  view plain copy

1. public void dispatchMessage(Message msg) {

2. if (msg.callback != null) {

3. handleCallback(msg);

4. } else {

5. if (mCallback != null) {

6. if (mCallback.handleMessage(msg)) {

7. return;

8. }

9. }

10. handleMessage(msg);

11. }

12. }

既然是分发消息的方法，那必然会根据消息的类型做出不同的处理，这个方法正是根据Message对象是否携带了callback，如果携带了callback那就执行handleCallback方法，callback之前分析Message类的时候已经知道是一个Runnable的对象了。下面我们看看handleCallback是什么实现的：

[java]  view plain copy

1. private static void handleCallback(Message message) {

2. message.callback.run();

3. }

一目了然！直接调用callback的run方法。之前我们用post方法发送消息时携带的Runnable对象在Handle内部被转化为一个Message：

[java]  view plain copy

1. private static Message getPostMessage(Runnable r) {

2. Message m = Message.obtain();

3. m.callback = r;

4. return m;

5. }

post方法中的Runnable对象被转成Message之后也会进入消息队列，最终被Looper抽取出来，让handler进行处理。

普通的sendMessage方法是不携带callback的，这时便进入dispatchMessage方法的else分支，进入else分支后，首先判断handler是否有一个CallBack的回调函数，如果有，直接调用回调函数的handMessage方法，这个CallBack是一个接口，它的好处是我们不用在继承Handler重写handleMessage方法了，CallBack接口定义：

[java]  view plain copy

1. public interface Callback {

2. public boolean handleMessage(Message msg);

3. }

如果没有实现回调接口，那么便调用Handle的handMessage方法处理消息。

-------------------------------------------

通过上面的一番分析，我们终于明白了android下的消息机制的运作原理了，为了更形象的说明整个流程，这里贴一张示意图：

==================================================================================================================

下面源码分析篇也是转载：

Android中消息传递模块差不多看了好几次，虽然每次看的方式都差不多但是还是发觉的到每次看了之后，理解的更清晰一点。

关于这个模块的文章数不胜数，但是最重要的还是自己动手理解一遍更好。

会牵扯到的几个类： Handler.java  , Looper.java , MessageQueue.java , Message.java

源代码路径：

xxx/frameworks/base/core/java/android/os  看的过程中你会发现高版本和低版本系统代码有些地方比较大的差距。从中我们可以分析为什么要做这样的修改，这样的修改的优点。

先看看在Looper类的注释中的一段代码。

[java]  view plain copy print ?

1. * 

   This is a typical example of the implementation of a Looper thread,

2. * using the separation of {@link #prepare} and {@link #loop} to create an

3. * initial Handler to communicate with the Looper.

4. *

5. * 

6. *  class LooperThread extends Thread {

7. *      public Handler mHandler;

8. *

9. *      public void run() {

10. *          Looper.prepare();

11. *

12. *          mHandler = new Handler() {

13. *              public void handleMessage(Message msg) {

14. *                  // process incoming messages here

15. *              }

16. *          };

17. *

18. *          Looper.loop();

19. *      }

20. *  }

21. */

Looper.java

这里Looper.prepare() ; 和 Looper.loop() ;这两个方法做了什么？

[java]  view plain copy print ?

1. /** Initialize the current thread as a looper.

2. * This gives you a chance to create handlers that then reference

3. * this looper, before actually starting the loop. Be sure to call

4. * {@link #loop()} after calling this method, and end it by calling

5. * {@link #quit()}.

6. */

7. public static void prepare() {

8. prepare(true);

9. }

10. private static void prepare(boolean quitAllowed) {

11. if (sThreadLocal.get() != null) {

12. throw new RuntimeException(“Only one Looper may be created per thread”);

13. }

14. //如果是main线程，则不允许退出。

15. sThreadLocal.set(new Looper(quitAllowed));

16. }

当我们手动调用Looper.prepare()方法的时候，内部调用prepare(boolean quitAllowd)方法，参数quitAllowd表示是否允许退出。

Android中刷新UI都在main线程中完成的，因此prepare(false)的时候是在启动main线程的时候会用到。我们可以看到Looper中另外一个方法：

[java]  view plain copy print ?

1. /**

2. * Initialize the current thread as a looper, marking it as an

3. * application’s main looper. The main looper for your application

4. * is created by the Android environment, so you should never need

5. * to call this function yourself.  See also: {@link #prepare()}

6. */

7. //查询该方法有两个位置用到。一是在SystemServer中，另外一个是在ActivityThread中。

8. //vi services/java/com/android/server/SystemServer.java +97

9. //vi core/java/android/app/ActivityThread.java +4985

10. public static void prepareMainLooper() {

11. prepare(false);

12. synchronized (Looper.class) {

13. if (sMainLooper != null) {

14. throw new IllegalStateException(“The main Looper has already been prepared.”);

15. }

16. sMainLooper = myLooper();

17. }

18. }

Looper.prepare()方法中，完成了Looper的创建并将起存储至ThreadLocal变量中。

从上面代码中可以看到：

sThreadLocal.set(new Looper(quitAllowed));

因此下面我们跟踪一下Looper的构造方法、

[java]  view plain copy print ?

1. private Looper(boolean quitAllowed) {

2. mQueue = new MessageQueue(quitAllowed);

3. mThread = Thread.currentThread();

4. }

构造方法中看到创建了MessageQueue和得到当前线程的Thread对象。这里的MessageQueue是后面消息循环以及消息的传递重要的部分。

因此，从这里我们可以看出，Looper中持有：MessageQueue，currentThread，ThreadLocal。

接下来看下，Looper.loop()方法。注：方法中部分打印Log相关的代码此处已经删除。

Android Source Code 4.4

[java]  view plain copy print ?

1. /**

2. * Run the message queue in this thread. Be sure to call

3. * {@link #quit()} to end the loop.

4. */

5. public static void loop() {

6. //获取当前looper

7. final Looper me = myLooper();

8. if (me == null) {

9. throw new RuntimeException(“No Looper; Looper.prepare() wasn’t called on this thread.”);

10. }

11. //Looper中持有消息队列。获取当前Looper的消息队列

12. final MessageQueue queue = me.mQueue;

13. // Make sure the identity of this thread is that of the local process,

14. // and keep track of what that identity token actually is.

15. Binder.clearCallingIdentity();

16. //无限循环

17. for (;😉 {

18. //取出消息

19. Message msg = queue.next(); // might block

20. if (msg == null) {

21. // No message indicates that the message queue is quitting.

22. return;

23. }

24. //++++++++++++++++++++这一句是重点，获取到消息后会回调到Handler方法中的handleMessage()方法中。

25. //在低版本的系统代码中，会判断msg.target==null，这里去掉了。

26. msg.target.dispatchMessage(msg);

27. //回收当前消息对象所占内存

28. msg.recycle();

29. }

30. }

对比Android Source Code 2.3

[java]  view plain copy print ?

1. /**

2. *  Run the message queue in this thread. Be sure to call

3. * {@link #quit()} to end the loop.

4. */

5. public static final void loop() {

6. Looper me = myLooper();

7. MessageQueue queue = me.mQueue;

8. // Make sure the identity of this thread is that of the local process,

9. // and keep track of what that identity token actually is.

10. Binder.clearCallingIdentity();

11. while (true) {

12. Message msg = queue.next(); // might block

13. //if (!me.mRun) {

14. //    break;

15. //}

16. if (msg != null) {

17. if (msg.target == null) {

18. // No target is a magic identifier for the quit message.

19. return;

20. }

21. msg.recycle();

22. }

23. }

24. }

从上面的对比可以看出4.4的代码明显比2.3的代码变化。

1.while(true){…}循环修改为for(,){…} 貌似这里没啥区别

2.Looper me = myLooper();获取到当前looper，4.4加了非空判断。因为在调用了Looper.prepare()后才会有Looper产生。可以看上面的分析。

3.去掉了message中target判断空的if语句。

分析为何这里去掉。

先看当我们调用Handler的handler.obtainMessage() ;

------->in Handler.java

[java]  view plain copy print ?

1. /**

2. * Returns a new {@link android.os.Message Message} from the global message pool. More efficient than

3. * creating and allocating new instances. The retrieved message has its handler set to this instance (Message.target == this).

4. *  If you don’t want that facility, just call Message.obtain() instead.

5. */

6. public final Message obtainMessage()

7. {

8. return Message.obtain(this);

9. }

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）

推荐学习资料

---

• 脑图
  
  
  
  由于文章篇幅问题点击链接查看详细文章以及获取学习笔记：GitHub

) [外链图片转存中…(img-U4P5wnGn-1710756468579)] [外链图片转存中…(img-2ID8z94P-1710756468580)]

1. /**

2. * Returns a new {@link android.os.Message Message} from the global message pool. More efficient than

3. * creating and allocating new instances. The retrieved message has its handler set to this instance (Message.target == this).

4. *  If you don’t want that facility, just call Message.obtain() instead.

5. */

6. public final Message obtainMessage()

7. {

8. return Message.obtain(this);

9. }

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-dCQTMZUU-1710756468580)]
[外链图片转存中…(img-HReZJAYm-1710756468580)]
[外链图片转存中…(img-7N6fY6DA-1710756468580)]
[外链图片转存中…(img-tHORf0Qh-1710756468581)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）
[外链图片转存中…(img-zKccI1XT-1710756468581)]

推荐学习资料

---

• 脑图
  [外链图片转存中…(img-BahK8wuo-1710756468581)]
  [外链图片转存中…(img-Zo7rRBZB-1710756468582)]
  [外链图片转存中…(img-6omYqJwP-1710756468582)]
  由于文章篇幅问题点击链接查看详细文章以及获取学习笔记：GitHub