Busy waiting
http://dbpedia.org/resource/Busy_waiting an entity of type: Thing
Aktives Warten (auch Verzögerungsschleife; englisch busy waiting oder spinning) bezeichnet eine Aktivität eines Computerprogramms, mit der die Zeit bis zur Erfüllung einer Bedingung aktiv, d. h. durch Ausführung von Anweisungen, welche den Zustand des Programms nicht verändern, überbrückt wird.
rdf:langString
En Informática, se denomina espera activa o espera ocupada a una técnica donde un proceso repetidamente verifica una condición, tal como esperar una entrada de teclado o si el ingreso a una sección crítica está habilitado.Puede ser una estrategia válida en algunas circunstancias especiales, sobre todo en la sincronización de procesos en los sistemas con múltiples procesadores (SMP). En general, debe ser evitada, ya que consume tiempo de CPU sin realizar ninguna operación.
rdf:langString
ビジーウェイト（英: busy waiting）とは、プロセスが条件が成り立つかどうかを定期的にチェックする手法の一種。例えば、キーボードからの入力を待ったり、ロックが獲得できるのを待ったりするのに使われる。ある時間だけ遅延させて何かを実行するのに使うこともある。
rdf:langString
바쁜 대기(영어: busy waiting 또는 spinning)란 어떠한 특정 공유자원에 대하여 두 개 이상의 프로세스나 스레드가 그 이용 권한을 획득하고자 하는 동기화 상황에서 그 권한 획득을 위한 과정에서 일어나는 현상이다. 대부분의 경우에 스핀락(Spin-lock)과 이것을 동일하게 생각하지만, 엄밀히 말하자면 스핀락이 바쁜 대기 개념을 이용한 것이다.
rdf:langString
Busy waiting is een techniek die in de softwareontwikkeling wordt toegepast om een proces op te houden totdat een bepaalde gebeurtenis plaats heeft gevonden.
rdf:langString
Em engenharia de software, espera ativa, espera ocupada ou espera ociosa é uma técnica em que um processo verifica uma condição repetidamente até que ela seja verdadeira, como esperar o pressionamento da tecla de um teclado ou a espera da liberação de recurso em exclusão mútua. Também pode ser usada para gerar atrasos na execução do sistema por um período determinado de tempo. Ela pode ser uma estratégia válida em certas circunstâncias, mas no geral é considerada um anti-padrão e deve ser evitada, já que o tempo de CPU gasto poderia ser usado noutra tarefa.
rdf:langString
在软件工程中，忙碌等待（也称自旋；英語：Busy waiting、busy-looping、spinning）是一种以进程反复检查一个条件是否为真为根本的技术，条件可能为键盘输入或某个锁是否可用。忙碌等待也可以用来产生一个任意的时间延迟，若系统没有提供生成特定时间长度的方法，则需要用到忙碌等待。不同的计算机处理器速度差异很大，特别是一些处理器设计为可能根据外部因素（例如操作系统上的负载）动态调整速率。因此，忙碌等待这种时间延迟技术容易产生不可预知、甚至不一致的结果，除非实现代码来确定处理器执行“什么都不做”循环的速度，或者循环代码明确检查实时时钟。 在某些情况下，忙碌等待是有效的策略，特别是实现自旋锁设计的操作系统上运行對稱多處理。不過一般来说，忙碌等待是应该避免的反模式，处理器时间應該用来执行其他任务，而不是浪费在无用的活动上。 对于，忙碌等待的优点是不切换线程，避免了由此付出的代价。因此一些多线程同步机制不使用切换到的同步对象，而是以用户态的自旋锁或其衍生机制（如轻型读写锁）来做同步，付出的时间复杂度相差3个数量级。忙碌等待可使用一些机制来降低CPU功耗，如Windows系统中调用YieldProcessor，实际上是调用了SIMD指令_mm_pause。
rdf:langString
En programació, espera activa (o busy waiting) és una tècnica en la qual un procés o un fil d'execució comprova repetidament si una condició és certa, per exemple, per saber si l'accés a una secció crítica està habilitat. L'espera activa consumeix temps de CPU sense realitzar cap operació, i per tant ha de ser emprada amb cura. Una aplicació comuna és la implementació de en els sistemes operatius dissenyats per funcionar en sistemes multiprocessador (SMP).
rdf:langString
Aktivní čekání je v programování označení pro takovou část počítačového programu, která v rámci podmíněného cyklu sama aktivně opakovaně ověřuje, zda už byla podmínka splněna, a v mezičase provádí nanejvýš nějaké jalové operace, například nulové instrukce. Situace, kdy by „čekání“ programu na splnění podmínky bylo správné implementovat neustálým dotazováním, zda už je splněna, jsou vzácné, v typických situacích se jedná o návrhový antivzor.
rdf:langString
Στην τεχνολογία λογισμικού το busy-waiting ή spinning είναι μια τεχνική που χρησιμοποιείται όταν προγραμματίζουμε με νήματα/threads. Η ιδέα είναι ότι το νήμα τρέχει ένα βρόχο επανάληψης μέχρι να ικανοποιηθεί κάποια συνθήκη. Για παράδειγμα μια κατάσταση busy-waiting είναι όταν μέσω ενός βρόχου επανάληψης ελέγχουμε αν ο χρήστης έχει εισάγει κάτι από το πληκτρολόγιο. Με την ίδια τεχνική μπορεί να δημιουργηθεί προσαρμοσμένη καθυστέρηση. Στον προγραμματισμό μικροελεγκτών δημιουργείται ένας γυμνός βρόχος (χωρίς να εκτελεί κώδικα) και ανάλογα με την ταχύτητα του μικροελεγκτή δημιουργεί μια καθυστέρηση στο εκτελέσιμο πρόγραμμα . Η τεχνική busy waiting χρησιμοποιείται στα spinlocks όπου ένα νήμα τρέχει ένα ατέρμονο βρόχο περιμένοντας πρόσβαση σε ένα πόρο του συστήματος. Όσο ο πόρος δεν είναι διαθέσ
rdf:langString
In computer science and software engineering, busy-waiting, busy-looping or spinning is a technique in which a process repeatedly checks to see if a condition is true, such as whether keyboard input or a lock is available. Spinning can also be used to generate an arbitrary time delay, a technique that was necessary on systems that lacked a method of waiting a specific length of time. Processor speeds vary greatly from computer to computer, especially as some processors are designed to dynamically adjust speed based on current workload. Consequently, spinning as a time-delay technique can produce unpredictable or even inconsistent results on different systems unless code is included to determine the time a processor takes to execute a "do nothing" loop, or the looping code explicitly checks
rdf:langString
L’attente active, en génie logiciel, ou polling (parfois appelée aussi « scrutation ») est une technique de programmation que les processus utilisent lorsqu'ils vérifient de façon répétée si une condition est vraie, comme l'attente d'une entrée (clavier ou autre) ou encore la libération d'un verrou.
rdf:langString
In informatica, e in particolare nei sistemi software concorrenti, l'espressione busy waiting o busy wait (letteralmente "attesa impegnata", più spesso tradotto come "attesa attiva") indica una tecnica di sincronizzazione per cui un processo o un thread che debba attendere il verificarsi di una certa condizione (per esempio la disponibilità di input dalla tastiera o di un proveniente da un altro processo) lo faccia verificando ripetutamente (ciclicamente) tale condizione. Questo approccio è alternativo all'uso di una sospensione del processo e del suo successivo risveglio tramite un segnale specifico (per esempio un interrupt nel caso dell'input da tastiera).
rdf:langString
Busy-waiting, busy-looping eller spinning är en teknik där en process upprepade gånger kontrollerar om ett tillstånd gäller, exempelvis om en tangentbordsinmatning eller ett datorlås finns tillgängligt. Spinning kan även användas för att generera en godtycklig fördröjning, en teknik som var nödvändig på system som saknade en metod för att vänta en specifik tidslängd. Processorhastigheter varierar kraftigt mellan datorer, speciellt då en del processorer är utformade för att dynamiskt justera hastigheten baserat på externa faktorer, som exempelvis belastningen på operativsystemet. Därför kan spinning som en tidsfördröjningsteknik ofta producera oförutsägbara eller t.o.m. inkonsistenta resultat såvida koden är implementerad för att bestämma hur snabbt processorn kan köra en tom loop, eller om
rdf:langString
Холостой цикл (также "холостое ожидание", англ. busy waiting) — реализация ожидания в компьютерной программе, в котором проверка определённого условия осуществляется в бесконечном цикле. Выход из бесконечного цикла происходит только при удовлетворении проверяемого условия. Также холостой цикл может использоваться для создания произвольной задержки выполнения программы.
rdf:langString
Холостий цикл — спосіб організації програми, при якому процес очікує настання певних подій шляхом неодноразової перевірки відповідних умов у циклі. При цьому мікропроцесор (центральний процесор комп'ютера чи вбудованої системи) лише перевіряє умови і повертається на початок циклу, не виконуючи при цьому ніякої корисної роботи, від чого і пішла назва циклу «холостий». Холостий цикл також може використовуватися для затримок виконання програми, але такий спосіб може давати значну похибку через різний час одного проходу циклу в залежності від системи.
rdf:langString
rdf:langString
Espera activa
rdf:langString
Aktivní čekání
rdf:langString
Aktives Warten
rdf:langString
Busy waiting
rdf:langString
Espera activa
rdf:langString
Busy waiting
rdf:langString
Attente active
rdf:langString
Busy waiting
rdf:langString
ビジーウェイト
rdf:langString
바쁜 대기
rdf:langString
Busy waiting
rdf:langString
Холостой цикл
rdf:langString
Espera ativa
rdf:langString
Busy-waiting
rdf:langString
Холостий цикл
rdf:langString
忙碌等待
xsd:integer
671489
xsd:integer
1079060252
rdf:langString
Aktivní čekání je v programování označení pro takovou část počítačového programu, která v rámci podmíněného cyklu sama aktivně opakovaně ověřuje, zda už byla podmínka splněna, a v mezičase provádí nanejvýš nějaké jalové operace, například nulové instrukce. Situace, kdy by „čekání“ programu na splnění podmínky bylo správné implementovat neustálým dotazováním, zda už je splněna, jsou vzácné, v typických situacích se jedná o návrhový antivzor. Podoba alternativy k aktivnímu čekání závisí na tom, za jakým účelem mělo být použito. Například je-li smyslem aktivního čekání spustit nějakou akci až v uvedený čas, je správným řešením zavolání takové funkce operačního systému, která daný proces odloží a vzbudí jej až v daný čas. Má-li být smyslem aktivního čekání synchronizace s jiným procesem, bude správnějším řešením použít vhodné synchronizační primitivum. Obecně ale platí, že místo neustálého dotazování na podmínku a tím zatěžování procesoru by mělo být čekání na podmínku vyřešeno prostředky operačního systému, jehož plánovač může čekající proces efektivně uspat a procesor raději přidělovat jiným procesům, dokud není podmínka splněna. Není-li z nějakých důvodů možné použít rozhraní operačního systému přímo pro čekání na danou podmínku, je vhodné alespoň implementovat líné aktivní čekání, kdy je mezi každým testováním podmínky na určitou konstantní dobu předáno řízení operačnímu systému. Většinu času pak proces stráví spaním, jen čas od času je operačním systémem vráceno řízení, proces si zkontroluje, zda už je podmínka splněna, a pokud ne, opět požádá operační systém, aby jej vzbudil až za určitý čas k další kontrole.
rdf:langString
En programació, espera activa (o busy waiting) és una tècnica en la qual un procés o un fil d'execució comprova repetidament si una condició és certa, per exemple, per saber si l'accés a una secció crítica està habilitat. L'espera activa consumeix temps de CPU sense realitzar cap operació, i per tant ha de ser emprada amb cura. Una aplicació comuna és la implementació de en els sistemes operatius dissenyats per funcionar en sistemes multiprocessador (SMP). Hi ha diverses alternatives a l'ús d'esperes actives. La majoria de sistemes operatius proveeixen crides de sistema que permeten bloquejar un procés en un event, com l'adquisició d'un semàfor, un rellotge de sistema, la disponibilitat d'un dispositiu d'entrada/sortida (I/O), etc., essent així innecessari realitzar espera activa. El planificador (scheduler) del sistema operatiu suspèn el procés i permet que la CPU sigui utilitzada per altres processos. Si és absolutament necessari realitzar una espera, es pot fer ús de funcions d'espera (delay) que són crides de sistema disponibles en la majoria de sistemes operatius. Aquestes funcions suspenen temporalment el procés o el fil d'execució que s'estava processant, i per tant no s'utilitzarà temps de CPU mentre duri la suspensió. Malgrat tot, en certs casos les esperes actives desitjables. Per exemple, en la implementació de controladors de baix nivell per a maquinari, on no és pràctic utilitzar senyalització mitjançant interrupcions. A vegades les esperes són de fet la forma més ràpida d'accedir a certes dades. Per exemple, pot ser necessari escriure dades de control a un dispositiu i llavors llegir algunes dades d'aquest que no són valides fins al cap de diversos cicles de rellotge. Si per exemple cridem una funció de sistema per retardar la lectura, pot ser que el temps involucrat en execució sigui molt major que el temps que volem estar esperant (degut a la sobrecàrrega involucrada en la crida a aquesta funció).
rdf:langString
Aktives Warten (auch Verzögerungsschleife; englisch busy waiting oder spinning) bezeichnet eine Aktivität eines Computerprogramms, mit der die Zeit bis zur Erfüllung einer Bedingung aktiv, d. h. durch Ausführung von Anweisungen, welche den Zustand des Programms nicht verändern, überbrückt wird.
rdf:langString
Στην τεχνολογία λογισμικού το busy-waiting ή spinning είναι μια τεχνική που χρησιμοποιείται όταν προγραμματίζουμε με νήματα/threads. Η ιδέα είναι ότι το νήμα τρέχει ένα βρόχο επανάληψης μέχρι να ικανοποιηθεί κάποια συνθήκη. Για παράδειγμα μια κατάσταση busy-waiting είναι όταν μέσω ενός βρόχου επανάληψης ελέγχουμε αν ο χρήστης έχει εισάγει κάτι από το πληκτρολόγιο. Με την ίδια τεχνική μπορεί να δημιουργηθεί προσαρμοσμένη καθυστέρηση. Στον προγραμματισμό μικροελεγκτών δημιουργείται ένας γυμνός βρόχος (χωρίς να εκτελεί κώδικα) και ανάλογα με την ταχύτητα του μικροελεγκτή δημιουργεί μια καθυστέρηση στο εκτελέσιμο πρόγραμμα . Η τεχνική busy waiting χρησιμοποιείται στα spinlocks όπου ένα νήμα τρέχει ένα ατέρμονο βρόχο περιμένοντας πρόσβαση σε ένα πόρο του συστήματος. Όσο ο πόρος δεν είναι διαθέσιμος το νήμα βρίσκεται σε κατάσταση αναμονής ή busy-waiting.
rdf:langString
In computer science and software engineering, busy-waiting, busy-looping or spinning is a technique in which a process repeatedly checks to see if a condition is true, such as whether keyboard input or a lock is available. Spinning can also be used to generate an arbitrary time delay, a technique that was necessary on systems that lacked a method of waiting a specific length of time. Processor speeds vary greatly from computer to computer, especially as some processors are designed to dynamically adjust speed based on current workload. Consequently, spinning as a time-delay technique can produce unpredictable or even inconsistent results on different systems unless code is included to determine the time a processor takes to execute a "do nothing" loop, or the looping code explicitly checks a real-time clock. In most cases spinning is considered an anti-pattern and should be avoided, as processor time that could be used to execute a different task is instead wasted on useless activity. Spinning can be a valid strategy in certain circumstances, most notably in the implementation of spinlocks within operating systems designed to run on SMP systems.
rdf:langString
En Informática, se denomina espera activa o espera ocupada a una técnica donde un proceso repetidamente verifica una condición, tal como esperar una entrada de teclado o si el ingreso a una sección crítica está habilitado.Puede ser una estrategia válida en algunas circunstancias especiales, sobre todo en la sincronización de procesos en los sistemas con múltiples procesadores (SMP). En general, debe ser evitada, ya que consume tiempo de CPU sin realizar ninguna operación.
rdf:langString
L’attente active, en génie logiciel, ou polling (parfois appelée aussi « scrutation ») est une technique de programmation que les processus utilisent lorsqu'ils vérifient de façon répétée si une condition est vraie, comme l'attente d'une entrée (clavier ou autre) ou encore la libération d'un verrou. Cette technique peut également être utilisée pour mettre en attente un programme pour une durée déterminée. Cela était nécessaire sur d'anciens systèmes d'exploitation dont le matériel sous-jacent ne proposait pas de méthode spécifique pour suspendre l'exécution du flot d'instruction pendant une période déterminée. Sur les plateformes modernes proposant des horloges et plusieurs vitesses de processeur, cette forme de suspension du programme est souvent imprécise et signe de programmation naïve. L'attente active peut, par contre, être une stratégie valide dans certaines circonstances, le plus souvent dans l'implémentation des spinlocks au sein de systèmes d'exploitation conçus pour fonctionner sur des systèmes à processeurs multiples. À part ce genre de cas, les attentes actives devraient être évitées, puisque le processeur pourrait être réattribué à une autre tâche.
rdf:langString
ビジーウェイト（英: busy waiting）とは、プロセスが条件が成り立つかどうかを定期的にチェックする手法の一種。例えば、キーボードからの入力を待ったり、ロックが獲得できるのを待ったりするのに使われる。ある時間だけ遅延させて何かを実行するのに使うこともある。
rdf:langString
In informatica, e in particolare nei sistemi software concorrenti, l'espressione busy waiting o busy wait (letteralmente "attesa impegnata", più spesso tradotto come "attesa attiva") indica una tecnica di sincronizzazione per cui un processo o un thread che debba attendere il verificarsi di una certa condizione (per esempio la disponibilità di input dalla tastiera o di un proveniente da un altro processo) lo faccia verificando ripetutamente (ciclicamente) tale condizione. Questo approccio è alternativo all'uso di una sospensione del processo e del suo successivo risveglio tramite un segnale specifico (per esempio un interrupt nel caso dell'input da tastiera). Nell'ingegneria del software si tende a evitare l'impiego del busy waiting laddove possibile; questa tecnica, infatti, presenta lo svantaggio di impegnare la CPU, in quanto ogni iterazione del ciclo di busy wait comporta l'esecuzione delle istruzioni che costituiscono la verifica della condizione attesa. La tecnica viene invece impiegata frequentemente nella progettazione dell'hardware.
rdf:langString
바쁜 대기(영어: busy waiting 또는 spinning)란 어떠한 특정 공유자원에 대하여 두 개 이상의 프로세스나 스레드가 그 이용 권한을 획득하고자 하는 동기화 상황에서 그 권한 획득을 위한 과정에서 일어나는 현상이다. 대부분의 경우에 스핀락(Spin-lock)과 이것을 동일하게 생각하지만, 엄밀히 말하자면 스핀락이 바쁜 대기 개념을 이용한 것이다.
rdf:langString
Busy waiting is een techniek die in de softwareontwikkeling wordt toegepast om een proces op te houden totdat een bepaalde gebeurtenis plaats heeft gevonden.
rdf:langString
Busy-waiting, busy-looping eller spinning är en teknik där en process upprepade gånger kontrollerar om ett tillstånd gäller, exempelvis om en tangentbordsinmatning eller ett datorlås finns tillgängligt. Spinning kan även användas för att generera en godtycklig fördröjning, en teknik som var nödvändig på system som saknade en metod för att vänta en specifik tidslängd. Processorhastigheter varierar kraftigt mellan datorer, speciellt då en del processorer är utformade för att dynamiskt justera hastigheten baserat på externa faktorer, som exempelvis belastningen på operativsystemet. Därför kan spinning som en tidsfördröjningsteknik ofta producera oförutsägbara eller t.o.m. inkonsistenta resultat såvida koden är implementerad för att bestämma hur snabbt processorn kan köra en tom loop, eller om loopkoden kollar en realtidsklocka. Spinning kan vara en bra strategi i vissa förhållanden, i synnerhet för implementationen av spinlock inom operativsystem som är byggda att köras på SMP-system. I allmänhet ses spinning som ett antimönster och bör undvikas då processortiden skulle kunna användas för att utföra en annan uppgift istället för att slösa på den på en meningslös aktivitet.
rdf:langString
Em engenharia de software, espera ativa, espera ocupada ou espera ociosa é uma técnica em que um processo verifica uma condição repetidamente até que ela seja verdadeira, como esperar o pressionamento da tecla de um teclado ou a espera da liberação de recurso em exclusão mútua. Também pode ser usada para gerar atrasos na execução do sistema por um período determinado de tempo. Ela pode ser uma estratégia válida em certas circunstâncias, mas no geral é considerada um anti-padrão e deve ser evitada, já que o tempo de CPU gasto poderia ser usado noutra tarefa.
rdf:langString
在软件工程中，忙碌等待（也称自旋；英語：Busy waiting、busy-looping、spinning）是一种以进程反复检查一个条件是否为真为根本的技术，条件可能为键盘输入或某个锁是否可用。忙碌等待也可以用来产生一个任意的时间延迟，若系统没有提供生成特定时间长度的方法，则需要用到忙碌等待。不同的计算机处理器速度差异很大，特别是一些处理器设计为可能根据外部因素（例如操作系统上的负载）动态调整速率。因此，忙碌等待这种时间延迟技术容易产生不可预知、甚至不一致的结果，除非实现代码来确定处理器执行“什么都不做”循环的速度，或者循环代码明确检查实时时钟。 在某些情况下，忙碌等待是有效的策略，特别是实现自旋锁设计的操作系统上运行對稱多處理。不過一般来说，忙碌等待是应该避免的反模式，处理器时间應該用来执行其他任务，而不是浪费在无用的活动上。 对于，忙碌等待的优点是不切换线程，避免了由此付出的代价。因此一些多线程同步机制不使用切换到的同步对象，而是以用户态的自旋锁或其衍生机制（如轻型读写锁）来做同步，付出的时间复杂度相差3个数量级。忙碌等待可使用一些机制来降低CPU功耗，如Windows系统中调用YieldProcessor，实际上是调用了SIMD指令_mm_pause。
rdf:langString
Холостой цикл (также "холостое ожидание", англ. busy waiting) — реализация ожидания в компьютерной программе, в котором проверка определённого условия осуществляется в бесконечном цикле. Выход из бесконечного цикла происходит только при удовлетворении проверяемого условия. Также холостой цикл может использоваться для создания произвольной задержки выполнения программы. В большинстве случаев холостой цикл считается антипаттерном, которого нужно избегать путём реорганизации кода или использование иного подхода к разработке (асинхронное выполнение, событийно-ориентированное программирование и т.п.).
rdf:langString
Холостий цикл — спосіб організації програми, при якому процес очікує настання певних подій шляхом неодноразової перевірки відповідних умов у циклі. При цьому мікропроцесор (центральний процесор комп'ютера чи вбудованої системи) лише перевіряє умови і повертається на початок циклу, не виконуючи при цьому ніякої корисної роботи, від чого і пішла назва циклу «холостий». Холостий цикл також може використовуватися для затримок виконання програми, але такий спосіб може давати значну похибку через різний час одного проходу циклу в залежності від системи. Також холостий цикл використовується при спін-блокуванні, коли час очікування суттєво менший за час перемикання між процесами.
xsd:nonNegativeInteger
7068