Android 中的 Handler 同步分割栏

最新推荐文章于 2024-07-24 13:28:06 发布
最新推荐文章于 2024-07-24 13:28:06 发布
阅读量698 收藏
点赞数
分类专栏： android 源码分析
Handler异步实现控制Message的处理的，异步线程可以在Handler中设置异步卡子，设置好了以后，当前Handler的同步Message都不再执行，直到异步线程将卡子去掉。

一、postSyncBarrier 设置同步卡

  • 方法是隐藏的需要反射获取
  • API版本<23方法位于Looper中，API版本>23位于
    MessageQueue中
  • 作用是为Handler设置卡子，过滤掉同步消息，同步消息等待执行

二、removeSyncBarrier 移除同步卡

  • 方法是隐藏的需要反射获取
  • API版本<23方法位于Looper中，API版本>23位于
    MessageQueue中
  • 作用是为Handler移除卡子，放开同步消息过滤，同步消息继续执行。
package qin.xue.imageviewscaletype.activity;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.MessageQueue;
import android.util.Log;

import java.lang.reflect.Method;

import qin.xue.imageviewscaletype.R;

/**
 * Created by qinxue on 2018/5/21.
 */

public class SyncBarrierActivity extends Activity {
    private static final String TAG = "SyncBarrierActivity";

    private Handler handler;
    private Handler workHanlder;
    private HandlerThread workHandlerThread;
    private Method methodPostSyncBarrier;
    private Looper looper;
    private int token;
    private int count = 0;
    private long start = 0;
    private long end = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.sync_barrier_activity_layout);
        workHandlerThread = new HandlerThread("work_thread");
        workHandlerThread.start();
        looper = workHandlerThread.getLooper();
        workHanlder = new Handler(looper);
        handler = new Handler();
        workHanlder.post(runnable);

        handler.post(new Runnable() {
            @Override
            public void run() {
                start = System.currentTimeMillis();
                Log.i(TAG, "设置同步卡 时间：" + start);
                postSyncBarrier();        //设置同步卡
            }
        });

        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                end = System.currentTimeMillis();
                Log.i(TAG, "移除同步卡 时间：" + end + "耗时：" + (end - start));
                removeSyncBarrier();    //5秒后移除同步卡
            }
        }, 5000);
    }

    //postSyncBarrier 和 removeSyncBarrier 方法是否在MessageQueue类中（api23及以上）
    private static boolean methodInQueue() {
        return android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M;
    }


    private Runnable runnable = new Runnable() {
        @Override
        public void run() {
            count++;
            Log.i(TAG, "count: " + count + "time: " + System.currentTimeMillis()); //同步打印数据
            workHanlder.postDelayed(runnable, 100);
        }
    };

    /**
     * 移除卡子
     */
    private void removeSyncBarrier() {
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
            removeSyncBarrier(looper.getQueue());
        } else {
            removeSyncBarrier(looper);
        }
    }

    private void removeSyncBarrier(Object obj) {
        try {
            Method method = MessageQueue.class.getMethod("removeSyncBarrier", int.class);
            method.invoke(obj, token);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 添加卡子
     */
    private void postSyncBarrier() {
        if (methodInQueue()) {
            postSyncBarrier(looper.getQueue());
        } else {
            postSyncBarrier(looper);
        }
    }

    private void postSyncBarrier(Object obj) {
        try {
            methodPostSyncBarrier = obj.getClass().getMethod("postSyncBarrier");
            token = (int) methodPostSyncBarrier.invoke(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

三、结果展示

05-21 17:44:22.926 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 1time: 1526895862926
05-21 17:44:22.947 12715-12715/qin.xue.imageviewscaletype I/SyncBarrierActivity: 设置同步卡 时间：1526895862947
05-21 17:44:27.931 12715-12715/qin.xue.imageviewscaletype I/SyncBarrierActivity: 移除同步卡 时间：1526895867930耗时：4983
05-21 17:44:27.932 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 2time: 1526895867932
05-21 17:44:28.033 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 3time: 1526895868033
05-21 17:44:28.134 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 4time: 1526895868134
05-21 17:44:28.236 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 5time: 1526895868235
05-21 17:44:28.336 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 6time: 1526895868336
05-21 17:44:28.437 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 7time: 1526895868437
05-21 17:44:28.538 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 8time: 1526895868538
05-21 17:44:28.639 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 9time: 1526895868639
05-21 17:44:28.739 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 10time: 1526895868739
05-21 17:44:28.841 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 11time: 1526895868841
05-21 17:44:28.941 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 12time: 1526895868941
05-21 17:44:29.043 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 13time: 1526895869043
05-21 17:44:29.144 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 14time: 1526895869144
05-21 17:44:29.244 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 15time: 1526895869244
05-21 17:44:29.345 12715-12732/qin.xue.imageviewscaletype I/SyncBarrierActivity: count: 16time: 1526895869345

四、代码解释

  • 代码中首先加了使用主线程设置异步线程workHandler中的异步卡子，导致workhandler中的Message不在执行，仅保留待执行。
  • 然后在5s之后在主线程移除了异步线程workHandler中的卡子，workhandler中的Message继续执行下去。

五、源码分析

我这里是6.0的源码
postSyncBarrier
 public int postSyncBarrier() {
        return postSyncBarrier(SystemClock.uptimeMillis());
    }

    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();
            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;
            }
            return token;
        }
    }

-这里可以看到这个卡子msg，新建了一个msg并根据时间插入到消息队列中，而且这个msg没有设置target

removeSyncBarrier
    public void removeSyncBarrier(int token) {
        // Remove a sync barrier token from the queue.
        // If the queue is no longer stalled by a barrier then wake it.
        synchronized (this) {
            Message prev = null;
            Message p = mMessages;
            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;
            if (prev != null) {
                prev.next = p.next;
                needWake = false;
            } else {
                mMessages = p.next;
                needWake = mMessages == null || mMessages.target != null;
            }
            p.recycleUnchecked();

            // If the loop is quitting then it is already awake.
            // We can assume mPtr != 0 when mQuitting is false.
            if (needWake && !mQuitting) {
                nativeWake(mPtr);
            }
        }
    }

-（p.target != null || p.arg1 != token）这里如果arg1 == token或者target为null，那么这是一个卡子。需要移除掉 ，代码如下。 prev.next = p.next;

next()
  • 在MessageQueue中还有这个方法，获取消息队列中的下一个Message
      if (msg != null && msg.target == null) {
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }

摘取部分代码，循环便利整个消息队列，如果target为null，那么直接利用isAsynchronous()找到下一个异步的message，跳过同步消息，设置执行时间。
大致就是这样。

Handler中还有阻塞机制

-如果发先下一条消息执行时间过长，会阻塞掉线程Looper循环的。在C++层，下次再研究下。

转载自原文

qinxue24
关注
专栏目录
android handler取消,Android Handler机制8之消息的取出与消息的其他操作
weixin_35397235的博客
05-27 806
Android Handler机制系列文章整体内容如下：本片文章的主要内容如下：1、消息的取出2、消息(Message)的移除3、关闭消息队列4、查看消息是否存在5、阻塞非安全执行一、消息的取出(一)、消息的取出主要是通过Looper的loop方法/*** Run the message queue in this thread. Be sure to call* {@link #quit()} ...
Android全面解析之由浅及深Handler消息机制
热门推荐
一只修仙的猿
10-08 1万+
前言 很高兴遇见你~ 欢迎阅读我的文章。 关于Handler的博客可谓是俯拾皆是，而这也是一个老生常谈的话题，可见的他非常基础，也非常重要。但很多的博客，却很少有从入门开始介绍，这在我一开始学习的时候就直接给我讲Looper讲阻塞，非常难以理解。同时，也很少有系统地讲解关于Handler的一切，知识比较零散。我希望写一篇从入门到深入，系统地全面地讲解Handler的文章，帮助大家认识Handler。 这篇文章的讲解深度循序渐进，不同程序的读者可选择对应的部分查看： 第一部分是对于Handler的入门概述。
使用Handler.post()对线程进行管理，实现同步
12-18
使用Handler.post()对线程进行管理，实现同步。这里使用post()将多个线程提交到Handler的MessageQueue里面，这样线程就会顺序执行，这样任务所操作的对象在同一时间里就不会有多个线程同时操作了，也就实现了同步操作了。同时注意，队列是同步操作的一个重要手段。
android handler同步,android解决：使用多线程和Handler同步更新UI
weixin_29370183的博客
05-30 173
如果运行时，可以看到滚动条由条慢慢变短，则说明程序成功了。截图如下，建议选择大点的文件做测试。 main.xmlxmlns:android="http://schemas.android.com/apk/res/android"android:layout_height="wrap_content" android:id="@+id/scrollView1" android:layout_w...
Android Handler之消息同步屏障
最新发布
xiangxiongfly
07-24 733
同步屏障：即消息的同步阻碍，指阻碍同步消息，只让异步消息通过。 平时我们通过 Handler 发送到消息大部分都是同步消息，当然也可以设置为异步消息。
android handler同步,5.4.3 Looper和Handler的同步关系
weixin_33796288的博客
05-30 144
Looper和Handler会有什么同步关系呢？它们之间确实有同步关系，而且如果不注意此关系，定要铸成大错！同步关系肯定和多线程有关，看下面的一个例子：**例子2**~~~/先定义一个LooperThread类class LooperThread extends Thread {publicLooper myLooper = null;//定义一个public的成员myLooper，初值为空。pu...
Android Handler之同步屏障机制
zenmela2011的专栏
09-17 1701
1.Message消息分类 Handler的Message分为3种：普通消息、屏障消息、异步消息。 其中普通消息又称为同步消息，屏障消息又称为同步屏障。 通常使用的都是普通消息，而屏障消息就是在消息队列中插入一个屏障，在屏障之后的所有普通消息都会被挡着，不能被处理。不过异步消息却例外，屏障不会挡住异步消息。因此可以这样认为：屏障消息就是为了确保异步消息的优先级，设置了屏障后，只能处理其后的异步消息，同步消息会被挡住，除非撤销屏障。 2.发送异步消息 通常使用Handler发消息时都是同步消息
Android_Handler机制详解及同步异步问题
Ricky‘s Home
04-18 8421
为了引入Handler消息机制，我们必须先知道“同步”和“异步”通信的差别   “同步”通信： 比如 我打电话给小明，跟小明进行对话，我必须等到和小明结束通话之后，才能再拨打其他人的电话 （同步就是发送一个请求之后，什么事都不做，一直等到结果返回后才继续做下面的事情）     "异步"通信： 比如 我给几个同学发送E-mail邮件，全部发送过去之后，不需要在这边等他
Android 音乐播放器歌词列表式同步显示功能源码.rar
09-16
源码中会有解析LRC文件的代码，通常涉及读取文件、分割时间戳和歌词对，然后将这些数据结构化存储以便后续使用。 3. **时间同步机制** 当音乐播放时，播放器会获取当前播放时间。根据这个时间，源码中的逻辑会找到...
Android面试题最全总结系列 (持续更新中...)
JasonGaoH的专栏
09-22 3056
前言 自己一直做Java、Android相关的知识总结->KnowledgeSummary系列。这个GitHub的repo想作为自己对于Android核心知识点以及一些面试题的总结，因为很多知识点理解的不够深刻，所以通过这个来强迫自己做总结，目前已经初具规模，我基本每天都会更新这个repo，后续还会持续更新下去，大家有兴趣可以点个star关注下，感谢。 在做这个知识总结系列，发现有的比较零散...
详解Android中的多线程断点下载
08-31
- 因为`ProgressBar`的更新可以在子线程中直接操作，所以不需要额外的Handler机制来同步主线程。 8. **多线程下载界面布局示例**： - 可以创建一个包含多个`ProgressBar`的布局，每个`ProgressBar`对应一个下载...
android handlerthread--线程和UI同步
安卓兼职framework和app工程师的博客
11-23 335
当我们需要工作线程来操作的时候，很多时候会有同步问题，UI更新问题。 Handle机制就是为了解决这个问题而产生的。 android允许每个线程都有自己的消息队列，同时也可以是主线程消息队列。 但是很多时候，我们希望可以快速的创建一个支持自己消息队列的android线程，这个时候HandlerThread就做了很好的封装。 package com.joyfulmath.demo.function;...
Android Handler之同步屏障机制(sync barrier)
qq_39431405的博客
01-06 1245
Handle的屏蔽消息，异步消息，同步消息
Android筑基——可视化方式理解 Handler 的同步屏障机制
willwaywang6
08-31 4042
网上有不少文章深入源码讲解 `Handler` 的同步屏障机制；也有一些作者贴心地举出了实际生活中的例子来帮助理解 `Handler` 的同步屏障机制。这都有助于大家理解 `Handler` 的同步屏障机制。 本文打算以**可视化的方式**展示 `Handler` 的同步屏障机制，更加直观地帮助大家理解 `Handler` 的同步屏障机制。
什么是Handler的同步屏障机制？，android适配器模式
m0_66264856的博客
01-27 349
正常插入消息会调用enqueueMessage方法，同时将handler赋值给message的target。 //将消息插入消息队列 private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg, long uptimeMillis) { msg.target = this; msg.workSourceUid = ThreadLocalWorkSource.getUid(); //进行判断是否将消息设置为异
关于Android Handler同步屏障那些事
贵公子丶笔记
04-17 288
肥柴总结一下异步消息和同步屏障。1、在一般情况下，异步消息和同步消息没有什么区别，但是一旦开启了同步屏障以后就有区别了。2、通过 MessageQueue 的方法可开启同步屏障，屏障消息是一个 target 为 null 的 Message。3、在 Looper 获取 MessageQueue 的时候，利用屏障消息是一个 target 为 null 的 Message 这一特性，当获取到的 Message 为屏障消息的时候，进入循环，遍历过滤掉所有的同步消息，直到取出异步消息为止。4、
Android中Handler的消息机制--同步屏障
qq_37837621的博客
10-05 590
ps：阅读原文可读性会好一些，原文链接：https://mp.weixin.qq.com/s/RIgyO85mFO5ZVXLXEdF9OA 前面我们花了很长时间用两篇文章（Android中Handler的消息机制分析（一）和Android中Handler的消息机制分析（二））分析 Handler 的消息机制，这一篇我们来分析 Handler 消息机制中的一种功能叫同步屏障；Message 可分为3种：普通消息、屏障消息和异步消息，其中普通消息又叫同步消息，屏障消息又叫同步屏障；屏障消息就是在消息队列中插入一
Handler系列——线程同步问题（二）
wqn的博客
07-19 435
目录1. Hadler的作用2. MessageQueue消息管理3. enqueueMessage源码4. next()源码 如果对handler了解不多先看上一篇handler基础： Handler又是什么鬼东西 1. Hadler的作用 handler是用于线程间通信的，但是它并不是仅仅用于处理UI界面，而更多的handler是整个app通信的框架。Android是基于事件驱动的，即所有的activity生命周期都是通过handler事件驱动的。 既然handler这么重要，那它的线程安全就至关重要，
Android中Handler
05-27
在Android中，Handler是一种用于实现线程之间通信的机制。使用Handler可以让你在主线程中处理后台线程的任务和更新UI界面。 Handler的主要作用是将Runnable或Message对象发送到MessageQueue中，然后Looper循环在MessageQueue中取出这些消息并处理。在Android中，UI线程就是一个Looper，因此可以通过Handler在UI线程中更新UI界面。 使用Handler一般需要以下步骤： 1. 创建Handler对象：可以在主线程中创建，也可以在子线程中创建。 2. 实现Runnable或Message对象：Runnable对象是一段可以在后台线程中执行的代码，Message对象包含了一些信息，可以在主线程中处理。 3. 将Runnable或Message对象发送到MessageQueue中：使用Handler的post方法将Runnable或Message对象发送到MessageQueue中。 4. 在主线程中处理Runnable或Message对象：当MessageQueue中有消息时，Looper循环会在主线程中处理这些消息。 需要注意的是，在使用Handler时要避免在主线程中执行耗时操作，因为这会导致UI线程卡顿。可以将耗时操作放到子线程中执行，然后使用Handler在主线程中更新UI界面。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值