Android多线程消息处理机制(四) Message、MessageQueue源码解析和Handler综合使用

最新推荐文章于 2021-03-05 18:56:37 发布
最新推荐文章于 2021-03-05 18:56:37 发布
阅读量1.7w 收藏 3
点赞数 3
分类专栏： Android 文章标签： android handler message looper thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fesdgasdgasdg/article/details/52098691
版权

先分析完Message，MessageQueue源码

/**
 * 获取Message的最好办法是调用Message.obtain()或Handler.obtainMessage()方法
 * 这将会从message pool中获取，避免硬创建导致过大的开销。
 */
public final class Message implements Parcelable {
    
    public int what;
    public int arg1; 
    public int arg2;
    public Object obj;

    /*package*/ int flags;//还可以用这个属性存放参数？

    /*package*/ long when;//还可以用这个属性存放参数？
    
    /*package*/ Bundle data;//还可以用这个属性存放参数？
    
    /*package*/ Handler target;//指定其处理场所，即宿主handler
    
    /*package*/ Runnable callback;//message可以包含回调
    
    // sometimes we store linked lists of these things
	// next？message在messageQueue中是链式存储？
    /*package*/ Message next;

    private static final Object sPoolSync = new Object();//对象锁
    private static Message sPool;
    private static int sPoolSize = 0;

    private static final int MAX_POOL_SIZE = 50;//message pool最大数量50个

    private static boolean gCheckRecycle = true;

    /**
     * 从全局池中返回一个新的消息实例。使我们能够避免在许多情况下分配新的对象.
     */
    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

    /**
     * 从消息池中获取一个message，设置orig的全部属性，浅克隆
     */
    public static Message obtain(Message orig) {
        Message m = obtain();
        m.what = orig.what;
        m.arg1 = orig.arg1;
        m.arg2 = orig.arg2;
        m.obj = orig.obj;
        m.replyTo = orig.replyTo;
        m.sendingUid = orig.sendingUid;
        if (orig.data != null) {
            m.data = new Bundle(orig.data);
        }
        m.target = orig.target;
        m.callback = orig.callback;

        return m;
    }

    /**
     * 获取message，指定target为h
     */
    public static Message obtain(Handler h) {
        Message m = obtain();
        m.target = h;
        return m;
    }

    /**
     * 获取message，指定特定的handler和callback
     */
    public static Message obtain(Handler h, Runnable callback) {
        Message m = obtain();
        m.target = h;
        m.callback = callback;

        return m;
    }

    /**
     * 将消息实例回收返回到全局消息池.
     * 在调用此函数后，你不能触摸这个消息，因为它已被释放了。
	 * 这是回收的消息，目前正在排队或是在被传递到处理过程中
     */
    public void recycle() {
        if (isInUse()) {
            if (gCheckRecycle) {
                throw new IllegalStateException("This message cannot be recycled because it "
                        + "is still in use.");
            }
            return;
        }
        recycleUnchecked();
    }

    /**
     * 回收一个message，放到消息池中
     */
    void recycleUnchecked() {
        // 清空所有的属性值
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }

    /**浅拷贝参数message o到当前的message对象中，
     * 但不拷贝linked list、timestamptarget、callback等属性的值。
     */
    public void copyFrom(Message o) {
        this.flags = o.flags & ~FLAGS_TO_CLEAR_ON_COPY_FROM;
        this.what = o.what;
        this.arg1 = o.arg1;
        this.arg2 = o.arg2;
        this.obj = o.obj;
        this.replyTo = o.replyTo;
        this.sendingUid = o.sendingUid;

        if (o.data != null) {
            this.data = (Bundle) o.data.clone();
        } else {
            this.data = null;
        }
    }

    /**
     * 设置一个任意数据的bundle数据包。如果没有复杂的数据需要传递，
	 * 你可以使用what,arg1,arg2,obj等的开销的属性传递。
     */
    public void setData(Bundle data) {
        this.data = data;
    }

    /**
     * 发送消息到你指定的handler的handleMessage()实现方法中执行，
	 * 如果没有指定message的target属性，则会抛异常
     */
    public void sendToTarget() {
        target.sendMessage(this);
    }

    /** 
	 * 构造方法，不推荐使用，优先Message.obtain()方法.
     */
    public Message() {
    }

    //...
}

总结：
1、Message就是数据对象，类似于java里面的bean。
2、创建方式很多，可以浅克隆，可以调用无参构造方法，可以obtain等，obtain是最推荐的，效率高。
3、Message有what、arg1、arg2、obj等属性存储普通数据，复杂的可以使用Bundle方式存储传递。
4、Message有个next属性，类型也是Message类型的，你猜猜是什么？看完下文你就会懂的。




下面看看MessageQueue部分源码： 

/**
 * 这是个低级别的消息队列类，由looper持有以及消息分发。
 * message不能直接的添加到这个队列中，而是通过handler对象关联的looper处理的。
 * 你可以通过Looper.myQueue()获取当前线程的消息队列引用。
 */
public final class MessageQueue {

    // message queue是否可以退出
    private final boolean mQuitAllowed;
	
	/**
	 * MessageQueue中的message都存放在mMessages中，这只是个链表头。
	 * 因为Message中有Message类型的next属性。回头看看Message源码
	 */
	Message mMessages;

	
	//此方法是messageQueue最核心的方法，handler.sendMessageXXXXXX()等方法最终调用的都是这个方法，
	//即经过一系列的处理，把message添加到messageQueue中
	boolean enqueueMessage(Message msg, long when) {
        
        //...
		
        synchronized (this) {
            //...

            msg.markInUse();
            msg.when = when;
            Message p = mMessages;//把链表头赋给p
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
			    //如果链表头为null，或者新的message是when为0，或者新message的when在链表中靠前
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                /**
				 * 插入队列的中间。通常情况下，我们不需要唤醒事件队列，
				 * 除非队列头上有一个障碍，消息是队列中最早的异步消息。
				 */
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
					//循环迭代，找到新message的when合适的位置
                    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;
    }
    
}

MessageQueue这个类我们平常很少接触到，但里面有一个重点需要了解，就是上面这个方法。
通过这个方法，handler把message添加到消息队列中。这些消息有即时的(0延时)，有延时的。这些message在消息队列中是怎么存放的呢？ 

when < p.when
新message的when与链表中某个message的when对比，时间小的放在前面。明白了吧？MessageQueue依据延时的长短，从小到大排序排序。


下面看handler用法demo：
方法一： 

/**
 * handler最普通的用法
 * 
 * @author duke
 *
 */
public class MainActivity extends Activity {

	private Handler mHandler = new Handler() {
		public void handleMessage(android.os.Message msg) {
			toast(String.valueOf(msg.obj));
		};
	};

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
	}

	public void testHandler(View view) {
		new Thread() {
			public void run() {
				mHandler.obtainMessage(200, "技术也是世界的，我们一起分享").sendToTarget();
			};
		}.start();
	}

	public void toast(String msg) {
		Toast toast = Toast.makeText(this, msg, Toast.LENGTH_SHORT);
		toast.setGravity(Gravity.CENTER, 0, 0);
		toast.show();
	}
}

方法二： 

/**
 * handler第二种用法
 * 注意：在oncreate、onstart、onresume期间没有getMainLooper()，
 * 关于在子线程中创建handler，参考：<a target=_blank href="http://blog.csdn.net/fesdgasdgasdg/article/details/52081773" target="_blank">http://blog.csdn.net/fesdgasdgasdg/article/details/52081773</a>
 * 也可以不传递looper，handler或自己获取当前线程的looper。
 * 此种方法没有实现handler的handleMessage方法
 * @author duke
 *
 */
public class MainActivity2 extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
	}
	
	private Handler mHandler;

	public void testHandler(View view) {
		mHandler = new Handler(getMainLooper());
		new Thread() {
			public void run() {
				mHandler.post(new Runnable() {
					@Override
					public void run() {
						toast("技术也是世界的，我们一起分享2");
					}
				});
			};
		}.start();
	}

	public void toast(String msg) {
		Toast toast = Toast.makeText(this, msg, Toast.LENGTH_SHORT);
		toast.setGravity(Gravity.CENTER, 0, 0);
		toast.show();
	}
}
方法三： 
/**
 * handler最普通的用法
 * new一个Callback，让他来帮助handler处理message
 * @author duke
 *
 */
public class MainActivity3 extends Activity {

	private Handler mHandler = new Handler(new Callback() {

		@Override
		public boolean handleMessage(Message msg) {
			toast(String.valueOf(msg.obj));
			//注意这儿返回true与false的区别
			return true;
		}
	});

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
	}

	public void testHandler(View view) {
		new Thread() {
			public void run() {
				mHandler.obtainMessage(200, "技术也是世界的，我们一起分享3").sendToTarget();
			};
		}.start();
	}

	public void toast(String msg) {
		Toast toast = Toast.makeText(this, msg, Toast.LENGTH_SHORT);
		toast.setGravity(Gravity.CENTER, 0, 0);
		toast.show();
	}
}

方法四： 

/**
 * handler最普通的用法
 * new一个callback，同时实现handler的handleMessage方法，同时处理消息
 * @author duke
 *
 */
public class MainActivity4 extends Activity {

	private Handler mHandler = new Handler(new Callback() {

		@Override
		public boolean handleMessage(Message msg) {
			toast(String.valueOf(msg.obj));
			//注意这儿返回true与false的区别
			return false;
		}
	}){
		@Override
		public void handleMessage(Message msg){
			//上面返回false，这儿同时也能处理消息
			toast(String.valueOf(msg.obj));
		}
	};

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
	}

	public void testHandler(View view) {
		new Thread() {
			public void run() {
				mHandler.obtainMessage(200, "技术也是世界的，我们一起分享4").sendToTarget();
			};
		}.start();
	}

	public void toast(String msg) {
		Toast toast = Toast.makeText(this, msg, Toast.LENGTH_SHORT);
		toast.setGravity(Gravity.CENTER, 0, 0);
		toast.show();
	}
}

方法五：

/**
 * handler最普通的用法
 * message中包含一个callback
 * @author duke
 *
 */
public class MainActivity5 extends Activity {

	private Handler mHandler = new Handler();

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main5);
	}

	public void testHandler(View view) {
		new Thread() {
			public void run() {
				Message msg = Message.obtain(mHandler, new Runnable() {
					@Override
					public void run() {
						toast("技术也是世界的，我们一起分享5");
					}
				});
				mHandler.sendMessage(msg);
			};
		}.start();
	}

	public void toast(String msg) {
		Toast toast = Toast.makeText(this, msg, Toast.LENGTH_SHORT);
		toast.setGravity(Gravity.CENTER, 0, 0);
		toast.show();
	}
}



是不是又看到了不少新鲜用法？

完了，Android多线程消息处理机制共四个章节，几乎都介绍完了。个人感觉介绍的很完整，相对于新手来说略有深度。


android阿杜
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
安卓多线程编程系列4：使用message的几种不同方式（不同的构造方法和使用方式）
luoshiwutai的博客
03-04 649
一个handler对应一个MessageQueue（消息队列），message是消息队列中数据的载体 Message（消息）：是用来携带数据的 MessageQueue（消息队列）：是用来存储消息的 handler：是用来发送和接收消息的 Looper：让消息队列一直进行循环的(管理整个这一摊事)，汉语是“环”的意思    是一个死循环:Looper会一直将handler中的message
[Android] 异步消息处理机制（Handler 、 Looper 、MessageQueue）源码解析
grace的专栏
06-15 529
1、Handler的由来 　　当程序第一次启动的时候，Android会同时启动一条主线程（ Main Thread）来负责处理与UI相关的事件，我们叫做UI线程。 　　Android的UI操作并不是线程安全的（出于性能优化考虑），意味着如果多个线程并发操作UI线程，可能导致线程安全问题。 　　为了解决Android应用多线程问题—Android平台只允许UI线程修改A
android多线程三（Message，MessageQueue)
pipisky2006的专栏
01-14 1518
Message 定义一个包含任意类型的描述数据对象，此对象可以发送给Handler。 尽管Message的构造器是公开的，但是获取Message对象的最好方法是调用Message.obtain()或者Handler.obtainMessage(), 这样是从一个可回收对象池中获取Message对象。 Message类是个final类，就是说不能被继承，同时Message类实现了Pa
Android多线程分析之四：MessageQueue的实现
dawuafang
07-14 118
Android多线程分析之四：MessageQueue的实现 罗朝辉 (http://blog.csdn.net/kesalin) CC 许可，转载请注明出处 在前面两篇文章《Android多线程分析之二：Thread的实现》，《Android多线程分析之三：Handler，Looper的实现》中分别介绍了 Thread 的创建，运行，销毁的过程以及 Thread与 Handler，Looper...
android多线程handler/message机制详解
06-20
主要对handler 、message机制进行了详解，如果想了解更多android相关知识，可以去我博客看看
Android多线程处理机制中的Handler使用介绍
01-20
在Android开发中，多线程处理机制是必不可少的一部分，它涉及到UI更新、后台任务执行以及高效资源管理等关键环节。Handler作为Android中的一个重要组件，它主要用于实现线程间通信和调度执行任务。以下是对Android ...
Handler Looper MessageQueue 源码解析
01-13
在Android系统中，Handler、Looper和MessageQueue是实现线程间通信的核心组件，它们共同构建了一个消息处理机制。本文将深入解析这三者的源码，帮助你理解它们的工作原理，并教你如何手写一套自己的Handler系统。 ...
深入Android Handler,MessageQueue与Looper关系
08-27
Android 消息机制是 Android 程序设计中非常重要的一部分，其中 Handler、MessageQueue 和 Looper 是三个紧密相关的概念。Handler 是 Android 消息机制的上层接口，我们在开发过程中只需要和 Handler 交互即可。...
Android的消息处理机制--Message，MessageQueue
09-02
本篇文章将详细探讨Android的消息处理机制，特别是Message和MessageQueue这两个核心概念。 #### 二、Android消息处理机制概述 当Android应用启动后，会创建一个主进程，在这个进程中包含了UI主线程。UI主线程负责...
Android Handler消息派发机制源码分析
01-20
Handler、Message和MessageQueue三者共同构成了Android的消息传递机制，使得开发者可以在不同的线程间进行通信，尤其是在UI更新和异步任务处理时。本文将深入解析Android Handler的`sendMessage`方法的工作流程。 ...
带有消息机制的线程 - CustomMessageQueue
03-11
自己建立一个线程，需要能够有时候让他执行一下，大部分时间还是阻塞着，这时候用我这个类就最合适了！
android多线程机制
01-12
通过上述介绍可以看出，Android的多线程机制主要依赖于`Handler`、`MessageQueue`、`Looper`和`Message`四个核心组件。它们共同协作，使得开发者能够在子线程中处理耗时任务，同时保证UI的更新始终发生在主线程中，...
Android多线程及异步任务消息处理机制 一 Handler的使用
08-26
在Android开发中，多线程和异步任务处理机制是至关重要的，特别是在处理耗时操作如网络请求、数据库操作或大型数据计算时。本篇博文将聚焦于Android中的`Handler`机制，它是Android异步消息处理的核心组件。通过`...
Android 之 Looper、MessageQueue、Handler 与消息循环
11-22
本文详细介绍了Android中消息处理机制的核心组件Looper、MessageQueue和Handler的工作原理及其实现细节。理解这些概念有助于开发者更好地设计和实现多线程应用程序，提高程序的性能和用户体验。通过合理利用这些组件...
Android7.0 MessageQueue详解
09-01
总之，Android 7.0中的MessageQueue是系统消息处理机制的核心，它在Java层和Native层都有相应的实现，以协调消息的发送、存储和处理。深入理解这一机制有助于开发者更好地控制应用程序的线程行为，实现高效且响应...
Android多线程机制
qq_30468305的博客
09-14 1585
问题1）为何需要多线程？ 在android中，在主线程中如果耗时太长会出现ANR（android not Responding），也就是看起来很卡； 一些下载图片，下载数据等耗时操作需要在其他线程执行。 一句话：避免应用太卡，需要使用多线程。2）多线程如何实现？ 多线程实现方式两种方式： implements Runnable 或 extends Thread3）多线程机制的核心是啥？
Android线程通信:Handler,MessageQueue和Looper原理分析
wsz的博客
07-16 753
分析Android线程通信机制，分析Handler、MessageQueue以及Looper的工作原理
Android线程间消息传递Handler、Looper、MessageQueue
qq_20647053的博客
03-05 260
1、Handler作用 主要场景是子线程完成耗时操作的过程中，通过Handler向主线程发送消息Message，用来刷新UI界面。 2、源码分析 2.1 Handler源码 final Looper mLooper; final MessageQueue mQueue; //Handler无参构造方法 public Handler() { this(null, false); } public Handler(Callback callback
Android——Message消息机制
小马同学
03-19 1972
Message是线程之间传递信息的载体，包含了对消息的描述和任意的数据对象。Message中包含了两个额外的 int字段和一个object字段，这样在大部分情况下，使用者就不需要再做内存分配工作了。虽然Message的构造函数是public的，但是最好是使用Message.obtain( )或Handler.obtainMessage( )函数来获取Message对象，因为Message的实现中包...
Android多线程机制解析：主线程与消息循环
"Android多线程机制以及Handler消息传递原理" 在Android开发中，多线程机制是必不可少的一个部分，尤其对于提升应用性能和用户体验至关重要。Android系统为了保证UI的流畅性，规定所有与用户界面交互的操作都必须在...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值