Joe Maring / Android Authority
TL;DR
- Google is introducing a new system in Android 17 to reduce time software threads spend waiting for each other to complete.
- By revising how access to memory is temporarily locked, DeliQueue lets threads run with fewer interruptions.
- That could result in a 4% reduction in apps dropping frames, or as high as 7.7% across the Android system UI.
You may not even be consciously thinking about it, but chances are you notice that something’s up when your Android phone isn’t running as smoothly as it could be. Everything still gets done — you swipe around, navigating the system UI, jumping in and out of apps — but sometimes scarifies need to be made for Android to keep up with you, and that can mean dropping frames. You might see it as stuttering, or scrolling that’s not quite as smooth as at other times. But with Android 17, Google’s introducing some changes that could make this phenomenon quite a bit less pronounced.
Don’t want to miss the best from Android Authority?
Over on its Android Developer Blog, Google shares a rather technical dive into changes coming to MessageQueue in Android 17. “What the heck is MessageQueue,” you ask? It’s a core part of the system Android apps use to display their UI.
The problem is, so far software threads have been able to temporarily lock the queue as they work with it, and that can lead to situations where one thread has to wait longer than it should for another to release the lock. If that takes too long, important processes don’t get completed in time, leading to user-facing consequences like dropped frames.
Google’s been aware of this limitation for some time, and the solution was clear, if not a little overwhelming: transition MessageQueue to a lock-free data structure. Basically, rather than locking out the entire queue, Android 17 implements a new system called DeliQueue that supports much more granular restrictions on specific locations in memory.
Anatomy of a dropped frame.
Without getting too dragged down into the how-and-why of it, threads aren’t forced to sit around waiting for others to release that lock before they’re able to do work of their own — and that lets them avoid bottlenecks that could result in janky, stuttering performance. Google explains that abandoning the old one-served-at-a-time approach is what led to the new system’s name:
This is like pulling a ticket at a deli counter – your number is determined by when you showed up, but the order you get your food in doesn’t have to match.
Developers still need to test their apps to make sure they’ll operate correctly with DeliQueue, but Google has put it through some pretty robust testing, and already corrected the two bugs that popped up.
What kind of improvements could you hope to actually see? In its tests, Google reports a 4% reduction in missed frames in apps, and a 7.7% reduction in missed frames in the system and launcher UI. That’s not huge, granted, but it’s still nice progress in the right direction. We can also look forward to apps starting up slightly faster.
Thank you for being part of our community. Read our Comment Policy before posting.
