Looper、Handler、Message以及消息队列模型

最新推荐文章于 2020-09-29 16:31:15 发布
最新推荐文章于 2020-09-29 16:31:15 发布
阅读量649 收藏
点赞数
分类专栏： 进击的兔子之JAVA基础 进击的兔子之Android基础

转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/38377229 ，本文出自【张鸿洋的博客】

很多人面试肯定都被问到过，请问Android中的Looper , Handler , Message有什么关系？本篇博客目的首先为大家从源码角度介绍3者关系，然后给出一个容易记忆的结论。

1、 概述

Handler 、 Looper 、Message 这三者都与Android异步消息处理线程相关的概念。那么什么叫异步消息处理线程呢？
异步消息处理线程启动后会进入一个无限的循环体之中，每循环一次，从其内部的消息队列中取出一个消息，然后回调相应的消息处理函数，执行完成一个消息后则继续循环。若消息队列为空，线程则会阻塞等待。

说了这一堆，那么和Handler 、 Looper 、Message有啥关系？其实Looper负责的就是创建一个MessageQueue，然后进入一个无限循环体不断从该MessageQueue中读取消息，而消息的创建者就是一个或多个Handler 。

2、 源码解析

1、Looper

对于Looper主要是prepare()和loop()两个方法。
首先看prepare()方法
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public static final void prepare() {  
  2.         if (sThreadLocal.get() != null) {  
  3.             throw new RuntimeException("Only one Looper may be created per thread");  
  4.         }  
  5.         sThreadLocal.set(new Looper(true));  
  6. }  

sThreadLocal是一个ThreadLocal对象，可以在一个线程中存储变量。可以看到，在第5行，将一个Looper的实例放入了ThreadLocal，并且2-4行判断了sThreadLocal是否为null，否则抛出异常。这也就说明了Looper.prepare()方法不能被调用两次，同时也保证了一个线程中只有一个Looper实例~相信有些哥们一定遇到这个错误。
下面看Looper的构造方法：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. private Looper(boolean quitAllowed) {  
  2.         mQueue = new MessageQueue(quitAllowed);  
  3.         mRun = true;  
  4.         mThread = Thread.currentThread();  
  5. }  
在构造方法中，创建了一个MessageQueue（消息队列）。
然后我们看loop()方法：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  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.   
  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.         final long ident = Binder.clearCallingIdentity();  
  12.   
  13.         for (;;) {  
  14.             Message msg = queue.next(); // might block  
  15.             if (msg == null) {  
  16.                 // No message indicates that the message queue is quitting.  
  17.                 return;  
  18.             }  
  19.   
  20.             // This must be in a local variable, in case a UI event sets the logger  
  21.             Printer logging = me.mLogging;  
  22.             if (logging != null) {  
  23.                 logging.println(">>>>> Dispatching to " + msg.target + " " +  
  24.                         msg.callback + ": " + msg.what);  
  25.             }  
  26.   
  27.             msg.target.dispatchMessage(msg);  
  28.   
  29.             if (logging != null) {  
  30.                 logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);  
  31.             }  
  32.   
  33.             // Make sure that during the course of dispatching the  
  34.             // identity of the thread wasn't corrupted.  
  35.             final long newIdent = Binder.clearCallingIdentity();  
  36.             if (ident != newIdent) {  
  37.                 Log.wtf(TAG, "Thread identity changed from 0x"  
  38.                         + Long.toHexString(ident) + " to 0x"  
  39.                         + Long.toHexString(newIdent) + " while dispatching to "  
  40.                         + msg.target.getClass().getName() + " "  
  41.                         + msg.callback + " what=" + msg.what);  
  42.             }  
  43.   
  44.             msg.recycle();  
  45.         }  
  46. }  

第2行：
public static Looper myLooper() {
return sThreadLocal.get();
}
方法直接返回了sThreadLocal存储的Looper实例，如果me为null则抛出异常，也就是说looper方法必须在prepare方法之后运行。
第6行：拿到该looper实例中的mQueue（消息队列）
13到45行：就进入了我们所说的无限循环。
14行：取出一条消息，如果没有消息则阻塞。
27行：使用调用 msg.target.dispatchMessage(msg);把消息交给msg的target的dispatchMessage方法去处理。Msg的target是什么呢？其实就是handler对象，下面会进行分析。
44行：释放消息占据的资源。

Looper主要作用：
1、 与当前线程绑定，保证一个线程只会有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。
2、 loop()方法，不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理。
好了，我们的异步消息处理线程已经有了消息队列（MessageQueue），也有了在无限循环体中取出消息的哥们，现在缺的就是发送消息的对象了，于是乎：Handler登场了。

2、Handler

使用Handler之前，我们都是初始化一个实例，比如用于更新UI线程，我们会在声明的时候直接初始化，或者在onCreate中初始化Handler实例。所以我们首先看Handler的构造方法，看其如何与MessageQueue联系上的，它在子线程中发送的消息（一般发送消息都在非UI线程）怎么发送到MessageQueue中的。
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public Handler() {  
  2.         this(null, false);  
  3. }  
  4. public Handler(Callback callback, boolean async) {  
  5.         if (FIND_POTENTIAL_LEAKS) {  
  6.             final Class<? extends Handler> klass = getClass();  
  7.             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&  
  8.                     (klass.getModifiers() & Modifier.STATIC) == 0) {  
  9.                 Log.w(TAG, "The following Handler class should be static or leaks might occur: " +  
  10.                     klass.getCanonicalName());  
  11.             }  
  12.         }  
  13.   
  14.         mLooper = Looper.myLooper();  
  15.         if (mLooper == null) {  
  16.             throw new RuntimeException(  
  17.                 "Can't create handler inside thread that has not called Looper.prepare()");  
  18.         }  
  19.         mQueue = mLooper.mQueue;  
  20.         mCallback = callback;  
  21.         mAsynchronous = async;  
  22.     }  

14行：通过Looper.myLooper()获取了当前线程保存的Looper实例，然后在19行又获取了这个Looper实例中保存的MessageQueue（消息队列），这样就保证了handler的实例与我们Looper实例中MessageQueue关联上了。

然后看我们最常用的sendMessage方法

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public final boolean sendMessage(Message msg)  
  2.  {  
  3.      return sendMessageDelayed(msg, 0);  
  4.  }  

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {  
  2.      Message msg = Message.obtain();  
  3.      msg.what = what;  
  4.      return sendMessageDelayed(msg, delayMillis);  
  5.  }  

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  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.    }  

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  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.    }  

辗转反则最后调用了sendMessageAtTime，在此方法内部有直接获取MessageQueue然后调用了enqueueMessage方法，我们再来看看此方法：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {  
  2.        msg.target = this;  
  3.        if (mAsynchronous) {  
  4.            msg.setAsynchronous(true);  
  5.        }  
  6.        return queue.enqueueMessage(msg, uptimeMillis);  
  7.    }  

enqueueMessage中首先为meg.target赋值为this，【如果大家还记得Looper的loop方法会取出每个msg然后交给msg,target.dispatchMessage(msg)去处理消息】，也就是把当前的handler作为msg的target属性。最终会调用queue的enqueueMessage的方法，也就是说handler发出的消息，最终会保存到消息队列中去。


现在已经很清楚了Looper会调用prepare()和loop()方法，在当前执行的线程中保存一个Looper实例，这个实例会保存一个MessageQueue对象，然后当前线程进入一个无限循环中去，不断从MessageQueue中读取Handler发来的消息。然后再回调创建这个消息的handler中的dispathMessage方法，下面我们赶快去看一看这个方法：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  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.     }  

可以看到，第10行，调用了handleMessage方法，下面我们去看这个方法：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.    * Subclasses must implement this to receive messages. 
  3.    */  
  4.   public void handleMessage(Message msg) {  
  5.   }  
  6.     
可以看到这是一个空方法，为什么呢，因为消息的最终回调是由我们控制的，我们在创建handler的时候都是复写handleMessage方法，然后根据msg.what进行消息处理。

例如：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. private Handler mHandler = new Handler()  
  2.     {  
  3.         public void handleMessage(android.os.Message msg)  
  4.         {  
  5.             switch (msg.what)  
  6.             {  
  7.             case value:  
  8.                   
  9.                 break;  
  10.   
  11.             default:  
  12.                 break;  
  13.             }  
  14.         };  
  15.     };  

到此，这个流程已经解释完毕，让我们首先总结一下

1、首先Looper.prepare()在本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象；因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。

2、Looper.loop()会让当前线程进入一个无限循环，不端从MessageQueue的实例中读取消息，然后回调msg.target.dispatchMessage(msg)方法。

3、Handler的构造方法，会首先得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue想关联。

4、Handler的sendMessage方法，会给msg的target赋值为handler自身，然后加入MessageQueue中。

5、在构造Handler实例时，我们会重写handleMessage方法，也就是msg.target.dispatchMessage(msg)最终调用的方法。

好了，总结完成，大家可能还会问，那么在Activity中，我们并没有显示的调用Looper.prepare()和Looper.loop()方法，为啥Handler可以成功创建呢，这是因为在Activity的启动代码中，已经在当前UI线程调用了Looper.prepare()和Looper.loop()方法。

3、Handler post

一般来说在工作线程中执行耗时任务，当任务完成时，会返回UI线程，一般是更新UI。这时有两种方法可以达到目的。
一种是handler.sendMessage。发一个消息，再根据消息，执行相关任务代码。

一种是handler.post(r)。r是要执行的任务代码。意思就是说r的代码实际是在UI线程执行的。可以写更新UI的代码。（工作线程是不能更新UI的）


 * 1 在子线程中利用post(Runnable r)更新UI,原理和sendMessage()类似.
 * 2 注意:
 *   在下面的示例中mHandler是主线程的Handler.
 *   所以“在子线程中利用post(Runnable r)更新UI”这个说法不是特别准确.
 *   确切地说还是在子线程中发送了消息到主线程的消息队列从而更新了UI.
 * 3 调用post(Runnable r)不会开启一个新的线程,UI的更新是在主线程中完成的！！！！！！！！！！
 *   所以在post方法中勿做耗时操作
public class MainActivity extends Activity {
    private TextView mTextView;
    private Handler mHandler;
    private Button mButton;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		init();
	}
    private void init(){
    	mHandler=new Handler();
    	mTextView=(TextView) findViewById(R.id.textView);
    	mButton=(Button) findViewById(R.id.button);
    	mButton.setOnClickListener(new OnClickListenerImpl());
    	System.out.println("UI线程ID="+Thread.currentThread().getId());
    }
    
  
    private class OnClickListenerImpl implements OnClickListener{
		@Override
		public void onClick(View v) {
			new Thread(){
	    		public void run() {
	    			mHandler.post(new Runnable() {
						@Override
						public void run() {
							mTextView.setText("My number is 007");
						}
					});
	    		};
	    	}.start();	
		}
    }
}

mCallback是个接口，可以这样来设置 Handler handler = new Handler(callback)，这个callback的意义是什么呢，代码里面的注释已经说了，可以让你不用创建Handler的子类但是还能照样处理消息，恐怕大家常用的方式都是新new一个Handler然后override其handleMessage方法来处理消息吧，从现在开始，我们知道，不创建Handler的子类也可以处理消息。多说一句，为什么创建Handler的子类不好？这是因为，类也是占空间的，一个应用class太多，其占用空间会变大，也就是应用会更耗内存。


今天有人问我，你说Handler的post方法创建的线程和UI线程有什么关系？

其实这个问题也是出现这篇博客的原因之一；这里需要说明，有时候为了方便，我们会直接写如下代码：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. mHandler.post(new Runnable()  
  2.         {  
  3.             @Override  
  4.             public void run()  
  5.             {  
  6.                 Log.e("TAG", Thread.currentThread().getName());  
  7.                 mTxt.setText("yoxi");  
  8.             }  
  9.         });  

然后run方法中可以写更新UI的代码，其实这个Runnable并没有创建什么线程，而是发送了一条消息，下面看源码：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public final boolean post(Runnable r)  
  2.    {  
  3.       return  sendMessageDelayed(getPostMessage(r), 0);  
  4.    }  
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. private static Message getPostMessage(Runnable r) {  
  2.       Message m = Message.obtain();  
  3.       m.callback = r;  
  4.       return m;  
  5.   }  
可以看到，在getPostMessage中，得到了一个Message对象，然后将我们创建的Runable对象作为callback属性，赋值给了此message.

注：产生一个Message对象，可以new  ，也可以使用Message.obtain()方法；两者都可以，但是更建议使用obtain方法，因为Message内部维护了一个Message池用于Message的复用，避免使用new 重新分配内存。

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  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.    }  
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  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.    }  
最终和handler.sendMessage一样，调用了sendMessageAtTime，然后调用了enqueueMessage方法，给msg.target赋值为handler，最终加入MessagQueue.

可以看到，这里msg的callback和target都有值，那么会执行哪个呢？

其实上面已经贴过代码，就是dispatchMessage方法：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  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.    }  
第2行，如果不为null，则执行callback回调，也就是我们的Runnable对象。

好了，关于Looper , Handler , Message 这三者关系上面已经叙述的非常清楚了。

最后来张图解：


希望图片可以更好的帮助大家的记忆~~

4、后话

其实Handler不仅可以更新UI，你完全可以在一个子线程中去创建一个Handler，然后使用这个handler实例在任何其他线程中发送消息，最终处理消息的代码都会在你创建Handler实例的线程中运行。

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. new Thread()  
  2.         {  
  3.             private Handler handler;  
  4.             public void run()  
  5.             {  
  6.   
  7.                 Looper.prepare();  
  8.                   
  9.                 handler = new Handler()  
  10.                 {  
  11.                     public void handleMessage(android.os.Message msg)  
  12.                     {  
  13.                         Log.e("TAG",Thread.currentThread().getName());  
  14.                     };  
  15.                 };<pre code_snippet_id="445431" snippet_file_name="blog_20140808_19_1943618" name="code" class="java">                               Looper.loop();                                                                                                                              }             </pre>  

Android不仅给我们提供了异步消息处理机制让我们更好的完成UI的更新，其实也为我们提供了异步消息处理机制代码的参考~~不仅能够知道原理，最好还可以将此设计用到其他的非Android项目中去~~

最新补充：

关于后记，有兄弟联系我说，到底可以在哪使用，见博客：Android Handler 异步消息处理机制的妙用 创建强大的图片加载类




消息队列模型


Android系统的消息队列和消息循环都是针对具体线程的，一个线程可以存在（当然也可以不存在）一个消息队列（Message Queue）和一个消息循环（Looper）。Android中除了UI线程（主线程），创建的工作线程默认是没有消息循环和消息队列的。如果想让该线程具有消息队列和消息循环，并具有消息处理机制，就需要在线程中首先调用Looper.prepare()来创建消息队列，然后调用Looper.loop()进入消息循环。如以下代码所示：

Java代码   收藏代码
  1. class LooperThread extends Thread {  
  2.       public Handler mHandler;  
  3.   
  4.       public void run() {  
  5.           Looper.prepare();
  6.     
  7.           mHandler = new Handler() {  
  8.               public void handleMessage(Message msg) {  
  9.                   // process incoming messages here  
  10.               }  
  11.           };  
  12.   
  13.           Looper.loop();  
  14.       }  
  15.   }  

       这样该线程就具有了消息处理机制了。如果不调用Looper.prepare()来创建消息队列，会报"java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()"的错误。

 

       通过下图可以清晰显示出UI Thread, Worker Thread, Handler, Massage Queue, Looper之间的关系：


 

 

Message

       消息对象，顾名思义就是记录消息信息的类。这个类有几个比较重要的字段：

       a.arg1和arg2：我们可以使用两个字段用来存放我们需要传递的整型值，在Service中，我们可以用来存放Service的ID。

       b.obj：该字段是Object类型，我们可以让该字段传递某个多项到消息的接受者中。

       c.what：这个字段可以说是消息的标志，在消息处理中，我们可以根据这个字段的不同的值进行不同的处理，类似于我们在处理Button事件时，通过switch(v.getId())判断是点击了哪个按钮。

       在使用Message时，我们可以通过new Message()创建一个Message实例，但是Android更推荐我们通过Message.obtain()或者Handler.obtainMessage()获取Message对象。这并不一定是直接创建一个新的实例，而是先从消息池中看有没有可用的Message实例，存在则直接取出并返回这个实例。反之如果消息池中没有可用的Message实例，则根据给定的参数new一个新Message对象。通过分析源码可得知，Android系统默认情况下在消息池中实例化10个Message对象。

 

      




概念

1. 什么是消息队列

消息队列在android中对应MessageQueue这个类，顾名思义，消息队列中存放了大量的消息（Message）

2.什么是消息

消息（Message）代表一个行为（what）或者一串动作（Runnable），有两处会用到Message：Handler和Messenger

3.什么是Handler和Messenger

Handler大家都知道，主要用来在线程中发消息通知ui线程更新ui。Messenger可以翻译为信使，可以实现进程间通信（IPC），Messenger采用一个单线程来处理所有的消息，而且进程间的通信都是通过发消息来完成的，感觉不能像AIDL那样直接调用对方的接口方法（具体有待考证），这是其和AIDL的主要区别，也就是说Messenger无法处理多线程，所有的调用都是在一个线程中串行执行的。Messenger的典型代码是这样的：new Messenger(service).send(msg)，它的本质还是调用了Handler的sendMessage方法

4.什么是Looper

Looper是循环的意思，它负责从消息队列中循环的取出消息然后把消息交给目标处理

5.线程有没有Looper有什么区别？

线程如果没有Looper，就没有消息队列，就无法处理消息，线程内部就无法使用Handler。这就是为什么在子线程内部创建Handler会报错："Can't create handler inside thread that has not called Looper.prepare()"，具体原因下面再分析。

6.如何让线程有Looper从而正常使用Handler？

在线程的run方法中加入如下两句：

Looper.prepare();

Looper.loop();

这一切不用我们来做，有现成的，HandlerThread就是带有Looper的线程。

想用线程的Looper来创建Handler，很简单，Handler handler = new Handler(thread.getLooper())，有了上面这几步，你就可以在子线程中创建Handler了，好吧，其实android早就为我们想到这一点了，也不用自己写，IntentService把我们该做的都做了，我们只要用就好了，具体怎么用后面再说。



在子线程创建Handler为什么会报错？

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public Handler(Callback callback, boolean async) {  
  2.     if (FIND_POTENTIAL_LEAKS) {  
  3.         final Class<? extends Handler> klass = getClass();  
  4.         if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&  
  5.                 (klass.getModifiers() & Modifier.STATIC) == 0) {  
  6.             Log.w(TAG, "The following Handler class should be static or leaks might occur: " +  
  7.                 klass.getCanonicalName());  
  8.         }  
  9.     }  
  10.     //获取当前线程的Looper  
  11.     mLooper = Looper.myLooper();  
  12.     //报错的根本原因是：当前线程没有Looper  
  13.     if (mLooper == null) {  
  14.         throw new RuntimeException(  
  15.             "Can't create handler inside thread that has not called Looper.prepare()");  
  16.     }  
  17.     mQueue = mLooper.mQueue;  
  18.     mCallback = callback;  
  19.     mAsynchronous = async;  
  20. }  
如何避免这种错误：在ui线程使用Handler或者给子线程加上Looper。


版权声明：本文为博主原创文章，未经博主允许不得转载。

rabbit_in_android
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 消息队列模型详解及实例
01-05
Android系统的消息队列和消息循环都是针对具体线程的，一个线程可以存在（当然也可以不存在）一个消息队列（Message Queue）和一个消息循环（Looper）。Android中除了UI线程（主线程），创建的工作线程默认是没有...
Looper中的消息队列处理机制
weixin_34007886的博客
01-31 134
Looper中的消息队列处理机制 Looper也提供了消息的定义、消息的发送、消息的处理者的自定义和消息队列。在其头文件Looper.h中，定义了消息结构体Message，它只有一个类型成员，Message的定义如下（见文件Looper.h，下同）：                         消息的处理者可由MessageHandler进行处理：   使用者可通过派生出子类来扩展消...
RabbitMQ的应用场景以及基本原理介绍
weixin_33834628的博客
07-10 1542
转载于：http://blog.csdn.net/whoamiyang/article/details/54954780，感谢作者1.背景RabbitMQ是一个由erlang开发的AMQP(Advanved Message Queue)的开源实现。2.应用场景2.1异步处理场景说明：用户注册后，需要发注册邮件和注册短信,传统的做法有两种1.串行的方式;2.并行的方式(1)串...
轻松搞定RabbitMQ（三）——消息应答与消息持久化
崔成龙 . 勇往直前
09-24 2万+
这个官网的第二个例子中的消息应答和消息持久化部分。我把它摘出来作为单独的一块儿来分享。 Message acknowledgment（消息应答）        执行一个任务可能需要花费几秒钟，你可能会担心如果一个消费者在执行任务过程中挂掉了。基于现在的代码，一旦RabbitMQ将消息分发给了消费者，就会从内存中删除。在这种情况下，如果杀死正在执行任务的消费者，会丢失正在处理的消息，也会丢失已经
（未完待续）浅谈微服务以及 常用中间件（ zookeeper redis rabbitmq）
舒婷(Zoe)
09-29 6061
传统的单体框架，已经不满足目前公司战略规划要求，近几年“微服务“ 这个字眼，出现的越来越频繁，虽然有过一年多微服务项目经验，也很难把微服务解释清楚，到底何为微服务？ 哈哈哈，好正经的开头，Martin Fowler曾在其blog上发表了”Microservices“的文章，正式提出了微服务架构，对于微服务的解释，他的定义为：微服务架构是一种架构模式，他 提倡将单一应用程序，划分为一个个独立的服务，服务之间相互协调，相互配合，为用户提供最终价值。 来一张图，感受一下微服务的魅力~ 将传统一个独...
RabbitMQ的几种应用场景
热门推荐
刀刀的专栏
12-15 5万+
之前的几篇文章介绍了一下RabbitMQ的概念以及环境的搭建和配置，有了RabbitMQ环境就可以基于其实现一些特殊的任务场景了。RabbitMQ官方有个很好的Tutorials基本覆盖了RabbitMQ的各中常见应用场景，先以代码加注释的方式以其Python客户端pika为例简单介绍如下。更详尽的信息可参阅：http://www.rabbitmq.com/getstarted.html R
Handler+Looper+MessageQueue+Message机制
01-03
作用： 跨线程通信，异步通信。...MessageQueue（消息队列）：由Looper负责管理，管理Handler发送过来的Message，其底层实现采用的是单链表。 Handler（处理者）：负责Message的发送及处理。通过 Handler.send
Android消息处理机制Looper和Handler详解
01-04
Message：消息，其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理。 Handler：处理者，负责Message的发送及处理。使用Handler时，需要实现handleMessage(Message msg)方法...
android开发教程之使用looper处理消息队列
01-20
import android.os.Handler; import android.os.HandlerThread; import android.os.Looper; import android.os.Message; public class HandlerActivity extends Activity {  @Override public void onCreate...
Android单线程模型中Message、Handler、Message Queue、Looper之间的关系---附实例源码
07-09
消息的类型，在Handler类中的handleMessage方法中得到单个的消息进行处理,在单线程模型下，为了线程通信问题，Android设计了一个Message Queue(消息队列)， 线程间可以通过该Message Queue并结合Handler和Looper组件...
Android消息机制好帮手—Looper、MessageQueue、Handler、Message
shu_lance的博客
08-20 192
基础常识 1、 Android 中只有主线程才能更新UI，Android机制的规定，主要是为了保证UI绘制的流畅，防止并发出问题； 2、 Android 中主线程不允许阻塞超过5s，否则可能会ANR； 3、 Handler机制的核心就是实现线程之间通信； 如何涉及一套线程间通信的机制？ Q1：如何涉及线程间通信？ A1：利用面向对象这个概念，创建一个对象obj，然后在子线程中给obj的一个属性赋值，然后在主线程中，操作obj对象，就可以拿到子线程赋值的结果，完成一次线程通信； Q2：主线程什么时候去操
python学习导航.txt
05-06
python
node-v8.3.0-linux-s390x.tar.xz
05-06
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
嵌入式微处理器设计及应用
05-06
摘要：为满足智能家居座椅的交互式运动控制需求，基于AT89S52设计了嵌入式座椅运动控制系统。使用VB.net设计了游戏手柄按键读取软件，并在此基础上设计了座椅运动控制软件，软件可分别在“手柄模式”和“鼠标模式”下与嵌入式座椅运动控制器通信，进而控制座椅进行加速、减速、正转和反转等运动；构建了控制系统实验装置，实验结果表明，“鼠标模式”下，通过鼠标点击控制软件上功能按钮可实现对座椅的准确运动控制；“手柄模式”下，游戏手柄不仅可控制座椅运动，还可同步控制电脑上运行的游戏或远程遥控车，实现浸入感较强的座椅运动娱乐应用。
2024年中国NFC RFID阅读器行业研究报告.docx
05-06
2024年中国NFC RFID阅读器行业研究报告
node-v9.9.0-linux-ppc64le.tar.xz
最新发布
05-06
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
04-18 周四 为LLM-inference项目配置GitHub CI过程记录
05-06
04-18 周四 为LLM-inference项目配置GitHub CI过程记录
2024年中国AI和机器视觉行业研究报告.docx
05-06
2024年中国AI和机器视觉行业研究报告
计算机二级【公共基础知识速学教程】.pdf
05-06
内容概要：这份资料包含了计算机二级公共基础知识速学教程的内容大纲，涵盖了数据结构与算法、程序设计基础、软件工程基础、数据库设计基础等多个章节。其中包括了算法复杂度、数据结构、栈、队列、链表、二叉树、查找、排序等内容，以及程序设计方法、软件工程概念、数据库设计原理等知识点。 适用人群：适合希望系统学习计算机二级公共基础知识的学生、计算机专业学习者、程序员、软件工程师以及对数据结构、算法和数据库设计感兴趣的人群，希望通过系统学习提升自己的计算机基础知识和技能。 使用场景及目标：该教程可用于计算机相关专业的课程学习、自学提升或备考计算机二级公共基础考试。学习者可以通过逐章学习和实践，掌握数据结构与算法、程序设计基础、软件工程基础和数据库设计基础等知识，提高自己在计算机领域的理论基础和实践能力。 其他说明：学习者在使用这份教程时，可以结合实际案例和练习题进行深入学习和巩固。建议按照章节顺序系统学习，理解各个知识点的概念和应用，并通过实践项目或练习加深对计算机基础知识的理解和掌握。通过系统学习，可以提升自己在计算机领域的专业水平和能力。
handler, looper, message
05-18
- Looper 是一个消息循环器，它负责在一个线程中不断地循环取出消息队列中的消息，并将其交给对应的 Handler 处理。通过调用 Looper.prepare() 和 Looper.loop() 方法，可以创建一个消息循环器并启动它的循环。 - ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值