Idle loop (også "idle waiting", engelsk busy waiting) - implementeringen af at vente i et computerprogram, hvor en bestemt tilstand kontrolleres i en endeløs loop. Udgangen fra den uendelige sløjfe sker kun, når betingelsen under test er opfyldt.
En inaktiv sløjfe kan også bruges til at skabe en vilkårlig forsinkelse i programafviklingen.
I de fleste tilfælde betragtes den inaktive sløjfe som et antimønster, der bør undgås ved at omfaktorere koden eller bruge en anden udviklingstilgang (asynkron eksekvering, hændelsesdrevet programmering osv.).
I kodestykket nedenfor venter en af trådene på værdien 0 i variablen i og fortsætter først efter det eksekveringen:
# include <pthread.h> # include <stdatomic.h> # include <stdio.h> # include <stdlib.h> # include <unistd.h> /* i er global, så den er synlig for alle funktioner. Det gør brug af det særlige * skriv atomic_int, som giver adgang til atomhukommelse. */ atomic_int i = 0 ; /* f1 bruger en spinlock til at vente på, at i ændres fra 0. */ statisk tomrum * f1 ( tomrum * p ) { int local_i ; /* Atomisk indlæse den aktuelle værdi af i i local_i og kontrollere, om denne værdi er nul */ mens (( local_i = atomic_load ( & i )) == 0 ) { /* gør ingenting - bare fortsæt med at tjekke igen og igen */ } printf ( "i's værdi er ændret til %d. \n " , local_i ); returner NULL ; } statisk tomrum * f2 ( tomrum * p ) { int local_i = 99 ; søvn ( 10 ); /* sov i 10 sekunder */ atomic_store ( & i , local_i ); printf ( "t2 har ændret værdien af i til %d. \n " , local_i ); returner NULL ; } int main () { int rc ; pthread_t t1 , t2 ; rc = pthread_create ( & t1 , NULL , f1 , NULL ); if ( rc != 0 ) { fprintf ( stderr , "pthread f1 mislykkedes \n " ); returner EXIT_FAILURE ; } rc = pthread_create ( & t2 , NULL , f2 , NULL ); if ( rc != 0 ) { fprintf ( stderr , "pthread f2 mislykkedes \n " ); returner EXIT_FAILURE ; } pthread_join ( t1 , NULL ); pthread_join ( t2 , NULL ); puts ( "Alle pthreads færdige." ); returnere 0 ; }Denne implementering bruger et kald til metoden Thread.sleep() i en loop, som giver dig mulighed for at suspendere udførelsen af en tråd i et givet antal millisekunder:
lang forsinkelse = 1L ; // tid i millisekunder volatile boolean waitForEvent = sand ; // værdi er indstillet fra andre tråde while ( waitForEvent ) { tråd . søvn ( forsinkelse ); }Samtidig giver skemalæggeren computerressourcer til andre tråde, hvorfor "sove" og "vågne" en tråd er dyre operationer. En anden ulempe ved denne metode er behovet for at håndtere undtagelsen, såvel som manglende evne til at suspendere tråden i mindre end 1 millisekund. Siden Java 9 er metoden Thread.onSpinWait() blevet introduceret, som giver dig mulighed for at implementere en kort ventetid uden at sætte tråden på pause:
volatile boolean waitForEvent = sand ; // værdi er indstillet fra andre tråde while ( waitForEvent ) { tråd . onSpitWait (); }Fordelen ved denne tilgang er evnen til straks at afbryde ventetiden og fortsætte eksekveringen.
En af undertyperne af ledig ventetid er en spinlock.
I lav-niveau programmering er tomgangsløkker mere udbredt. I praksis er en afbrydelse ikke altid ønskelig for nogle hardwareenheder. For eksempel, hvis det er nødvendigt at skrive nogle kontroloplysninger til enheden og modtage et svar om resultaterne af skrivningen, kan udvikleren vende sig til forsinkelsesfunktionen på OS-niveau, men dets opkald kan tage længere tid, så en aktiv ventetid cyklus bruges.