Thank you, everybody, for your kind input!
Having said that, I fully agree with all your proposals, but need to
say: I already knew them, and it was **not** what I actually asked for.
To repeat: "Is there a *best practice*". If the question is unclear, let
me rephrase it using an example:
"Is there a document that contains a short and simple rule set that we
(the core-libs contributors) apply in busy-wait cases BY DEFAULT when we
do *not* decide to explicitly optimize for any special case?"
It could look like this:
BUSY-WAIT BEST PRACICE
In case you MUST use busy-wait, apply the following rules:
* NEVER have EMPTY busy-wait loops, but ALWAYS put Thread.onSpinWait()
into it. The performance drop is negligible but the CO2 footprint is
considerably smaller.
* IF it is acceptable for the waiting thread to not have the *absolute*
maximum throughput, put Thread.yield() before Thread.onSpinWait() in the
busy-wait loop, so CPU cores are more efficiently used.
* Never use Thread.sleep() in busy-wait loops.
* If possible, pin current thread to current CPU core to prevent
inefficient context switches.
* ...more rules...
THAT is what my question is targeting! :-)
Thanks!
-Markus
Am 16.06.2025 um 12:22 schrieb Per-Ake Minborg:
Hi Markus, and thank you for your question, which I think is a very
relevant one.
There is no silver bullet here. It all depends on the problem at hand.
One of the major questions to ask is what the aim of the solution is:
are you optimizing latency, throughput, power efficiency, fairness, a
certain SLA etc.
If you have considered asynchronous programming, I would encourage you
to instead take a look at virtual threads, which provide a much more
robust programming model. I think this is, indeed, a best practice
approach in this type of choices.
If you are dealing with latency sensitive stuff, sometimes starting
out with a busy wait (calling Thread.onSpinWait()) and then
progressively backing off to yield() and wait() could be a good
strategy. This can be combined with thread pinning and CPU isolation
on the OS level to get improved latency metrics. Sometimes, event
loops are a good choice in this domain.
Best, Per Minborg
------------------------------------------------------------------------
*From:* core-libs-dev <core-libs-dev-r...@openjdk.org> on behalf of
Chen Liang <chen.l.li...@oracle.com>
*Sent:* Sunday, June 15, 2025 10:42 PM
*To:* Markus KARG <mar...@headcrashing.eu>; Archie Cobbs
<archie.co...@gmail.com>
*Cc:* core-libs-dev <core-libs-dev@openjdk.org>
*Subject:* Re: Best Practice for Busy Waiting in Java
Not a concurrency professional, but my first impression is whether to
yield or spin depends on how costly the task you are waiting is - I
know yield involves a context switch and can be problematic for small
waits.
In addition, in Java, many blocking happens in a way users cannot
control - for example, class initialization. Those might be bigger
bottlenecks compared to the explicit busy waits.
Chen
Get Outlook for Android <https://aka.ms/AAb9ysg>
------------------------------------------------------------------------
*From:* core-libs-dev <core-libs-dev-r...@openjdk.org> on behalf of
Markus KARG <mar...@headcrashing.eu>
*Sent:* Sunday, June 15, 2025 11:49:52 AM
*To:* Archie Cobbs <archie.co...@gmail.com>
*Cc:* core-libs-dev <core-libs-dev@openjdk.org>
*Subject:* Re: Best Practice for Busy Waiting in Java
Seems you misunderstood my question. It was *not* what is best to do.
It was: "Does the core-libs team have a common-sense / best practice
for busy-wait.". The latter is a clear and concise question, and the
answer could be as simple as "yes" or "no".
Am 15.06.2025 um 18:40 schrieb Archie Cobbs:
Just MHO...
This is kind of like asking "What's the best way to waste electricity?"
It's a nebulous question until you specify what "best" means in this
odd scenario....
-Archie
On Sun, Jun 15, 2025 at 11:09 AM Markus KARG <mar...@headcrashing.eu
<mailto:mar...@headcrashing.eu>> wrote:
Recently I was asked by a programmer, what to do if there simply
is no
other way than actually busy-wait.
I see several options:
* Do nothing: Costs valuable CPU time and increases carbon footprint.
* Do a power-nap: Thread.sleep(1)
* Be fair: Thread.yield() gives other threads a chance to execute in
this time slot.
* Be eco-friendly: Thread.onSpinWait() could reduce carbon footprint.
* A combination of that, like "Thread.yield(); Thread.onSpinWait();"
As all of that has its pros and cons, and as all of that works
differently on each hardware platform, I do wonder if there is some
common sense / best practice for busy wait (other than "Replace
it using
async") in the core-libs team?
Thanks!
-Markus
--
Archie L. Cobbs
