Message next() {
    for (;;) {
        // 1. 發(fā)現(xiàn)屏障消息（target==null）
        if (msg != null && msg.target == null) {
            do {
                prevMsg = msg;
                msg = msg.next;
            // 2. 跳過(guò)所有同步消息
            } while (msg != null && !msg.isAsynchronous());
        }
        
        // 3. 優(yōu)先執(zhí)行異步消息
        if (msg != null) {
            return msg;
        }
    }
}

class CustomView @JvmOverloads constructor(
    context: Context, 
    attrs: AttributeSet? = null
) : View(context, attrs) {

    private val handler = Handler(Looper.getMainLooper())
    private var barrierToken: Int = 0

    // 啟動(dòng)繪制流程
    fun scheduleDrawing() {
        // 1. 插入同步屏障
        try {
            val queue = Looper.getMainLooper().queue
            val method = queue.javaClass.getDeclaredMethod("postSyncBarrier")
            barrierToken = method.invoke(queue) as Int
        } catch (e: Exception) {
            Log.e("SyncBarrier", "Failed to post barrier", e)
        }

        // 2. 發(fā)送異步繪制任務(wù)
        val asyncMsg = Message.obtain().apply {
            what = MSG_DRAW
            isAsynchronous = true
        }
        handler.sendMessageDelayed(asyncMsg, 0)
    }

    // 移除屏障
    fun completeDrawing() {
        try {
            val queue = Looper.getMainLooper().queue
            val method = queue.javaClass.getDeclaredMethod(
                "removeSyncBarrier", 
                Int::class.javaPrimitiveType
            )
            method.invoke(queue, barrierToken)
        } catch (e: Exception) {
            Log.e("SyncBarrier", "Failed to remove barrier", e)
        }
    }

    companion object {
        private const val MSG_DRAW = 1
    }
}

class ANRMonitor(private val timeout: Long = 5000) {
    
    private val mainHandler = Handler(Looper.getMainLooper())
    private var barrierToken = 0
    
    fun start() {
        // 插入同步屏障
        barrierToken = postSyncBarrier()
        
        // 發(fā)送高優(yōu)先級(jí)檢測(cè)任務(wù)
        mainHandler.postDelayed({
            if (!taskCompleted) {
                // ANR發(fā)生！
                reportANR()
            }
            removeSyncBarrier(barrierToken)
        }, timeout).apply { 
            setAsynchronous(true) 
        }
    }
    
    // 反射實(shí)現(xiàn)屏障操作
    private fun postSyncBarrier(): Int {
        return try {
            val queue = Looper.getMainLooper().queue
            val method = queue.javaClass.getDeclaredMethod("postSyncBarrier")
            method.invoke(queue) as Int
        } catch (e: Exception) {
            -1
        }
    }
}

class SyncBarrierDemo {

    fun demonstrate() {
        // 創(chuàng)建帶Looper的線程
        val thread = HandlerThread("SyncBarrierDemo").apply { start() }
        val handler = Handler(thread.looper)
        
        // 1. 發(fā)送普通消息
        handler.post { log("普通消息1") }
        handler.post { log("普通消息2") }
        
        // 2. 插入同步屏障
        val token = postSyncBarrier(thread.looper)
        
        // 3. 發(fā)送異步消息
        handler.post {
            Message.obtain().apply {
                isAsynchronous = true
                handler.sendMessage(this)
            }
            log("===== 異步消息執(zhí)行 =====")
        }
        
        // 4. 再發(fā)送普通消息
        handler.post { log("普通消息3") }
        
        // 5. 移除屏障
        Handler(Looper.getMainLooper()).postDelayed({
            removeSyncBarrier(thread.looper, token)
        }, 1000)
    }

    private fun postSyncBarrier(looper: Looper): Int {
        return try {
            val queue = looper.queue
            val method = queue.javaClass.getDeclaredMethod("postSyncBarrier")
            method.invoke(queue) as Int
        } catch (e: Exception) {
            -1
        }
    }
    
    private fun removeSyncBarrier(looper: Looper, token: Int) {
        try {
            val queue = looper.queue
            val method = queue.javaClass.getDeclaredMethod(
                "removeSyncBarrier", 
                Int::class.javaPrimitiveType
            )
            method.invoke(queue, token)
        } catch (e: Exception) {
            // 處理異常
        }
    }
    
    private fun log(msg: String) {
        Log.d("SyncBarrier", "[${Thread.currentThread().name}] $msg")
    }
}

 普通消息1
 普通消息2
 ===== 異步消息執(zhí)行 =====
 普通消息3

// 正確寫(xiě)法
val token = postSyncBarrier()
try {
    // 執(zhí)行異步任務(wù)
} finally {
    removeSyncBarrier(token)
}

fun setMessageAsync(msg: Message) {
    if (Build.VERSION.SDK_INT >= 22) {
        msg.isAsynchronous = true
    } else {
        // 低版本備用方案
    }
}

VSYNC信號(hào) → 插入屏障 → 執(zhí)行繪制 → 移除屏障

class PriorityEventBus {
    private val barrierMap = ConcurrentHashMap<Class<*>, Int>()
    
    fun postHighPriority(event: Any) {
        val eventType = event.javaClass
        barrierMap[eventType] = postSyncBarrier()
        // 發(fā)送異步事件...
    }
    
    fun complete(event: Any) {
        barrierMap[event.javaClass]?.let {
            removeSyncBarrier(it)
        }
    }
}

fun renderAnimationFrame() {
    postSyncBarrier()
    val startTime = SystemClock.uptimeMillis()
    renderFrame() // 異步執(zhí)行
    postDelayed({
        removeSyncBarrier()
    }, 16 - (SystemClock.uptimeMillis() - startTime))
}

object SyncBarrierUtil {

    /**
     * 安全執(zhí)行高優(yōu)先級(jí)任務(wù)
     * @param block 需要優(yōu)先執(zhí)行的任務(wù)
     * @param looper 目標(biāo)Looper（默認(rèn)主線程）
     */
    fun executeWithPriority(block: () -> Unit, looper: Looper = Looper.getMainLooper()) {
        val token = postSyncBarrier(looper)
        try {
            Handler(looper).post {
                Message.obtain().apply {
                    isAsynchronous = true
                }
                block()
            }
        } finally {
            removeSyncBarrier(looper, token)
        }
    }

    private fun postSyncBarrier(looper: Looper): Int {
        return try {
            val queue = looper.queue
            val method = queue.javaClass.getDeclaredMethod("postSyncBarrier")
            method.invoke(queue) as Int
        } catch (e: Exception) {
            -1
        }
    }

    private fun removeSyncBarrier(looper: Looper, token: Int) {
        if (token == -1) return
        try {
            val queue = looper.queue
            val method = queue.javaClass.getDeclaredMethod(
                "removeSyncBarrier", 
                Int::class.javaPrimitiveType
            )
            method.invoke(queue, token)
        } catch (e: Exception) {
            // 處理異常
        }
    }
}