Spinlock
http://dbpedia.org/resource/Spinlock an entity of type: WikicatConcurrencyControlAlgorithms
Στην τεχνολογία λογισμικού το spinlock είναι μηχανισμός κλειδώματος ενός νήματος/thread που θέλει να αποκτήσει πρόσβαση σε ένα πόρο. Κατά τον μηχανισμό αυτόν, το νήμα περιμένει "τρέχοντας" ατέρμονα βρόχο επανάληψης (loop/spin), με τον οποίο ελέγχει την κατάσταση του κλειδώματος. Το νήμα καθώς εκτελεί τον βρόχο αυτόν βρίσκεται σε αναμονή (ονομάζεται η κατάσταση αυτή busy waiting). Όταν το νήμα αποκτήσει πρόσβαση στο κλείδωμα, την διατηρεί μέχρι να ολοκληρωθεί ο κώδικας εκτέλεσης του νήματος. Ένα spin lock στην πράξη είναι μηχανισμός κλειδώματος mutex σε κάποιους κοινούς πόρους, ο οποίος στην πράξη μπλοκάρει ένα νήμα κάνοντάς το να βρίσκεται σε κατάσταση busy-waiting καθώς εκτελεί ατέρμονα βρόχο ελέγχου κλειδώματος (το spinlocκ).
rdf:langString
Ein Spinlock (Spin-Lock) ist ein Mechanismus zur Prozesssynchronisation. Es ist eine Sperre (Lock) zum Schutz einer gemeinsam genutzten Ressource durch konkurrierende Prozesse bzw. Threads (siehe Kritischer Abschnitt) nach dem Prinzip des wechselseitigen Ausschlusses (Mutex).
rdf:langString
En programmation informatique et plus particulièrement en programmation concurrente, le spinlock ou verrou tournant est un mécanisme simple de synchronisation basé sur l'attente active. Le spinlock base son principe sur l'attente active. En attendant leur tour, les threads l'utilisant vont le tester de manière répétée jusqu'à ce qu'il se libère. Pour ce faire, les threads doivent impérativement utiliser une opération atomique afin de garder le principe de l'exclusion mutuelle.
rdf:langString
스핀락(spinlock)은 임계 구역(critical section)에 진입이 불가능할 때 진입이 가능할 때까지 루프를 돌면서 재시도하는 방식으로 구현된 락을 가리킨다. 스핀락이라는 이름은 락을 획득할 때까지 해당 스레드가 빙빙 돌고 있다(spinning)는 것을 의미한다. 스핀락은 바쁜 대기의 한 종류이다. 스핀락은 운영 체제의 스케줄링 지원을 받지 않기 때문에, 해당 스레드에 대한 문맥 교환이 일어나지 않는다. 따라서 스핀락은 임계 구역에 짧은 시간 안에 진입할 수 있는 경우에 문맥 교환을 제거할 수 있어 효율적이다. 하지만 만약 스핀락이 오랜 시간을 소요한다면 다른 스레드를 실행하지 못하고 대기하게 되며, 이 경우 비효율적인 결과를 가져온다.
rdf:langString
In informatica uno spinlock o anche spinning è una tecnica di programmazione che utilizza un ciclo di attesa attiva (busy waiting) per implementare la routine di attesa di un lock. La tecnica consiste nel verificare periodicamente se il lock è stato sbloccato, effettuando un test che può aver luogo ad intervalli di tempo prestabiliti, oppure nel tempo più breve possibile consentito dal sistema.
rdf:langString
自旋锁是计算机科学用于多线程同步的一种锁，线程反复检查锁变量是否可用。由于线程在这一过程中保持执行，因此是一种忙等待。一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁。 自旋锁避免了进程上下文的调度开销，因此对于线程只会阻塞很短时间的场合是有效的。因此操作系统的实现在很多地方往往用自旋锁。Windows操作系统提供的轻型读写锁（SRW Lock）内部就用了自旋锁。显然，单核CPU不适于使用自旋锁，这里的单核CPU指的是单核单线程的CPU，因为，在同一时间只有一个线程是处在运行状态，假设运行线程A发现无法获取锁，只能等待解锁，但因为A自身不挂起，所以那个持有锁的线程B没有办法进入运行状态，只能等到操作系统分给A的时间片用完，才能有机会被调度。这种情况下使用自旋锁的代价很高。 获取、释放自旋锁，实际上是读写自旋锁的存储内存或寄存器。因此这种读写操作必须是原子的。通常用test-and-set等原子操作来实现。
rdf:langString
Spinlock je v operačních systémech druh zámku, na nějž je třeba aktivně čekat – čekající proces tedy při čekání na spinlock spotřebovává systémové prostředky. Spinlocky se zpravidla používají pouze v operačním systému, aplikacím jsou poskytována složitější synchronizační primitiva, které čekající aplikace uspí a zařadí do fronty, takže v době, kdy jsou zablokovány, může běžet něco jiného. Na druhou stranu, tyto složitější struktury vyžadují ochranu svých dat proti vícenásobnému přístupu, a k tomu lze použít právě jednodušší a rychlejší spinlocky.
rdf:langString
En ingeniería de software , un spinlock es un bloqueo que hace que un hilo que intenta adquirirlo simplemente espere en un bucle ("girar" en inglés "spin") mientras comprueba repetidamente si el bloqueo(lock) está disponible. Como el hilo permanece activo pero no está realizando una tarea útil, el uso de dicho bloqueo es una especie de espera ocupada . Una vez adquiridos, los spinlocks generalmente se mantendrán hasta que se liberen explícitamente, aunque en algunas implementaciones se pueden liberar automáticamente si el hilo que está esperando en (lo que contiene el bloqueo) bloquea, o "se va a dormir".
rdf:langString
In software engineering, a spinlock is a lock that causes a thread trying to acquire it to simply wait in a loop ("spin") while repeatedly checking whether the lock is available. Since the thread remains active but is not performing a useful task, the use of such a lock is a kind of busy waiting. Once acquired, spinlocks will usually be held until they are explicitly released, although in some implementations they may be automatically released if the thread being waited on (the one that holds the lock) blocks or "goes to sleep".
rdf:langString
スピンロック（英: spin lock, spinlock）とは、計算機科学におけるロックの一種で、スレッドがロックを獲得できるまで単純にループ（スピン）して定期的にロックをチェックしながら待つ方式。スレッドはその間有益な仕事を何もせずに動作し続けるため、これは一種のビジーウェイト状態を発生させる。獲得されたスピンロックは明示的に解放するまでそのまま確保されるが、実装によってはスレッドがブロック（スリープ）したときに自動的に解放される場合もある。 スピンロックを正しく実装することは難しい。なぜなら、競合状態を避けるためにロックの同時アクセスの可能性を考慮しなければならないからである。一般に、これは特別なアセンブリ言語の命令（アトミックなテスト・アンド・セット操作など）を使う必要があり、高級言語やアトミック命令をサポートしていない言語では簡単には実装できない。アトミック命令をサポートしないアーキテクチャや、高級言語で実装しなければならない場合、ピーターソンのアルゴリズムといったアトミックでないロックアルゴリズムを用いることができるかもしれない。ただし、スピンロックより多くのメモリが必要になるかもしれないし、アウト・オブ・オーダー実行が許される場合は高級言語では実装できないかもしれない。
rdf:langString
Spinlock (wirująca blokada) – sposób realizacji synchronizacji międzyprocesowej, w którym oczekiwanie na zwolnienie blokady polega na ciągłym badaniu jej stanu. Spinlock działa więc na zasadzie aktywnego oczekiwania, tj. zużywa czas procesora, wykonując cały czas pustą pętlę: while blokada aktywna do {nic nie rób}; W systemie Windows NT sekcje krytyczne na maszynach wieloprocesorowych używają podejścia mieszanego: najpierw określoną liczbę razy sprawdza się, czy blokada została zwolniona, dopiero jeśli w tym czasie się nie zwolni, realizowany jest systemowy kod synchronizacji.
rdf:langString
Спин-блокировка или спинлок (англ. spinlock — циклическая блокировка) — низкоуровневый примитив синхронизации, применяемый в многопроцессорных системах для реализации взаимного исключения исполнения критических участков кода с использованием цикла активного ожидания. Применяется в случаях, когда ожидание захвата блокировки предполагается недолгим либо если контекст выполнения не позволяет переходить в заблокированное состояние.
rdf:langString
rdf:langString
Spinlock
rdf:langString
Spinlock
rdf:langString
Spinlock
rdf:langString
Spinlock
rdf:langString
Spinlock
rdf:langString
Spinlock
rdf:langString
스핀락
rdf:langString
スピンロック
rdf:langString
Spinlock
rdf:langString
Spinlock
rdf:langString
Спин-блокировка
rdf:langString
自旋锁
xsd:integer
244603
xsd:integer
1078478659
rdf:langString
Spinlock je v operačních systémech druh zámku, na nějž je třeba aktivně čekat – čekající proces tedy při čekání na spinlock spotřebovává systémové prostředky. Spinlocky se zpravidla používají pouze v operačním systému, aplikacím jsou poskytována složitější synchronizační primitiva, které čekající aplikace uspí a zařadí do fronty, takže v době, kdy jsou zablokovány, může běžet něco jiného. Na druhou stranu, tyto složitější struktury vyžadují ochranu svých dat proti vícenásobnému přístupu, a k tomu lze použít právě jednodušší a rychlejší spinlocky. Příklad implementace spinlocku v assembleru architektury x86: zacatek:mov eax, 1 ; přesuneme jedničku do registruxchg eax, [ $zamek ] ; jednou instrukcí atomicky prohodíme obsah registru ; s proměnnou držící zámek. nyní je v proměnné určitě jedničkatest eax, eax ; pokud je v registru nula, zámek byl před prohozením ; odemčený, tudíž jsme jej získali a můžeme pokračovatjnz zacatek ; … jinak to zkusíme znovu od začátku; ( kritická sekce )mov eax, 0 ; konec, vrátíme do proměnné nulu a tím zámek odemknemexchg eax, [ $zamek ] ; na toto by měla fungovat i prostá instrukce mov, ; ale na některých procesorech se pokazí
rdf:langString
Στην τεχνολογία λογισμικού το spinlock είναι μηχανισμός κλειδώματος ενός νήματος/thread που θέλει να αποκτήσει πρόσβαση σε ένα πόρο. Κατά τον μηχανισμό αυτόν, το νήμα περιμένει "τρέχοντας" ατέρμονα βρόχο επανάληψης (loop/spin), με τον οποίο ελέγχει την κατάσταση του κλειδώματος. Το νήμα καθώς εκτελεί τον βρόχο αυτόν βρίσκεται σε αναμονή (ονομάζεται η κατάσταση αυτή busy waiting). Όταν το νήμα αποκτήσει πρόσβαση στο κλείδωμα, την διατηρεί μέχρι να ολοκληρωθεί ο κώδικας εκτέλεσης του νήματος. Ένα spin lock στην πράξη είναι μηχανισμός κλειδώματος mutex σε κάποιους κοινούς πόρους, ο οποίος στην πράξη μπλοκάρει ένα νήμα κάνοντάς το να βρίσκεται σε κατάσταση busy-waiting καθώς εκτελεί ατέρμονα βρόχο ελέγχου κλειδώματος (το spinlocκ).
rdf:langString
Ein Spinlock (Spin-Lock) ist ein Mechanismus zur Prozesssynchronisation. Es ist eine Sperre (Lock) zum Schutz einer gemeinsam genutzten Ressource durch konkurrierende Prozesse bzw. Threads (siehe Kritischer Abschnitt) nach dem Prinzip des wechselseitigen Ausschlusses (Mutex).
rdf:langString
En ingeniería de software , un spinlock es un bloqueo que hace que un hilo que intenta adquirirlo simplemente espere en un bucle ("girar" en inglés "spin") mientras comprueba repetidamente si el bloqueo(lock) está disponible. Como el hilo permanece activo pero no está realizando una tarea útil, el uso de dicho bloqueo es una especie de espera ocupada . Una vez adquiridos, los spinlocks generalmente se mantendrán hasta que se liberen explícitamente, aunque en algunas implementaciones se pueden liberar automáticamente si el hilo que está esperando en (lo que contiene el bloqueo) bloquea, o "se va a dormir". Debido a que evitan la sobrecarga de la reprogramación de procesos del sistema operativo o el cambio de contexto , los spinlocks son eficientes si es probable que los hilos se bloqueen solo por períodos cortos. Por esta razón, los kernels del sistema operativo a menudo usan spinlocks. Sin embargo, los spinlocks se vuelven un desperdicio si se mantienen durante más tiempo, ya que pueden evitar que otros hilos se ejecuten y requieren reprogramación. Cuanto más tiempo un hilo mantiene un bloqueo, mayor es el riesgo de que el programador(scheduler) del sistema operativo interrumpa el hilo mientras mantiene el bloqueo. Si esto sucede, otros hilos se dejarán "girando" (tratando repetidamente de adquirir el candado), mientras que el hilo que sujeta el candado no está avanzando hacia su liberación. El resultado es un aplazamiento indefinido hasta que el hilo que sujeta la cerradura pueda terminar y soltarlo. Esto es especialmente cierto en un sistema de procesador único, donde cada subproceso en espera de la misma prioridad puede desperdiciar su cantidad (tiempo asignado en que se puede ejecutar un subproceso) girando hasta que el subproceso que contiene el bloqueo finalice finalmente. Implementar bloqueos de giro correctamente ofrece desafíos porque los programadores deben tener en cuenta la posibilidad de acceso simultáneo a la cerradura, lo que podría causar condiciones de carrera . En general, dicha implementación solo es posible con instrucciones especiales en lenguaje de ensamblaje, como operaciones atómicas de prueba y configuración , y no se puede implementar fácilmente en lenguajes de programación que no admitan operaciones verdaderamente atómicas. [1] En arquitecturas sin tales operaciones, o si se requiere la implementación de lenguaje de alto nivel, se puede usar un algoritmo de bloqueo no atómico, por ejemplo, el algoritmo de Peterson . Sin embargo, tal implementación puede requerir más memoria que un spinlock, ser más lenta para permitir el progreso después del desbloqueo, y puede no ser implementable en un lenguaje de alto nivel si se permite la ejecución fuera de orden .
rdf:langString
En programmation informatique et plus particulièrement en programmation concurrente, le spinlock ou verrou tournant est un mécanisme simple de synchronisation basé sur l'attente active. Le spinlock base son principe sur l'attente active. En attendant leur tour, les threads l'utilisant vont le tester de manière répétée jusqu'à ce qu'il se libère. Pour ce faire, les threads doivent impérativement utiliser une opération atomique afin de garder le principe de l'exclusion mutuelle.
rdf:langString
In software engineering, a spinlock is a lock that causes a thread trying to acquire it to simply wait in a loop ("spin") while repeatedly checking whether the lock is available. Since the thread remains active but is not performing a useful task, the use of such a lock is a kind of busy waiting. Once acquired, spinlocks will usually be held until they are explicitly released, although in some implementations they may be automatically released if the thread being waited on (the one that holds the lock) blocks or "goes to sleep". Because they avoid overhead from operating system process rescheduling or context switching, spinlocks are efficient if threads are likely to be blocked for only short periods. For this reason, operating-system kernels often use spinlocks. However, spinlocks become wasteful if held for longer durations, as they may prevent other threads from running and require rescheduling. The longer a thread holds a lock, the greater the risk that the thread will be interrupted by the OS scheduler while holding the lock. If this happens, other threads will be left "spinning" (repeatedly trying to acquire the lock), while the thread holding the lock is not making progress towards releasing it. The result is an indefinite postponement until the thread holding the lock can finish and release it. This is especially true on a single-processor system, where each waiting thread of the same priority is likely to waste its quantum (allocated time where a thread can run) spinning until the thread that holds the lock is finally finished. Implementing spinlocks correctly is challenging because programmers must take into account the possibility of simultaneous access to the lock, which could cause race conditions. Generally, such an implementation is possible only with special assembly-language instructions, such as atomic test-and-set operations and cannot be easily implemented in programming languages not supporting truly atomic operations. On architectures without such operations, or if high-level language implementation is required, a non-atomic locking algorithm may be used, e.g. Peterson's algorithm. However, such an implementation may require more memory than a spinlock, be slower to allow progress after unlocking, and may not be implementable in a high-level language if out-of-order execution is allowed.
rdf:langString
스핀락(spinlock)은 임계 구역(critical section)에 진입이 불가능할 때 진입이 가능할 때까지 루프를 돌면서 재시도하는 방식으로 구현된 락을 가리킨다. 스핀락이라는 이름은 락을 획득할 때까지 해당 스레드가 빙빙 돌고 있다(spinning)는 것을 의미한다. 스핀락은 바쁜 대기의 한 종류이다. 스핀락은 운영 체제의 스케줄링 지원을 받지 않기 때문에, 해당 스레드에 대한 문맥 교환이 일어나지 않는다. 따라서 스핀락은 임계 구역에 짧은 시간 안에 진입할 수 있는 경우에 문맥 교환을 제거할 수 있어 효율적이다. 하지만 만약 스핀락이 오랜 시간을 소요한다면 다른 스레드를 실행하지 못하고 대기하게 되며, 이 경우 비효율적인 결과를 가져온다.
rdf:langString
スピンロック（英: spin lock, spinlock）とは、計算機科学におけるロックの一種で、スレッドがロックを獲得できるまで単純にループ（スピン）して定期的にロックをチェックしながら待つ方式。スレッドはその間有益な仕事を何もせずに動作し続けるため、これは一種のビジーウェイト状態を発生させる。獲得されたスピンロックは明示的に解放するまでそのまま確保されるが、実装によってはスレッドがブロック（スリープ）したときに自動的に解放される場合もある。 スレッドが短時間だけブロックされるならば、スピンロックは効率的であり、オペレーティングシステムのプロセススケジューリングのオーバーヘッドを防ぐことにもなる。このため、スピンロックはカーネル内でよく使われる。しかし、確保期間が長くなるとスピンロックは無駄が多くなり、他のスレッドの処理を妨害するだけでなく、再スケジューリングが必要になることもある。スレッドがロックを保持する時間が長くなればなるほど、ロックを持った状態でOSスケジューラによって割り込まれる可能性が高くなる。もしそうなると、ロックを保持しているスレッドがロックを解放することがないにも関わらず、他のスレッドは（ロックを繰り返し獲得しようとして）スピンし続けてしまう。その結果、ロックを保持するスレッドがロックを解放するまで、他のスレッドは先に進むことができない（indefinite postponement状態になる）。これはシングルプロセッサシステムには特に当てはまる。というのも、他のスレッドが並行して動くことは決してないので、いったんスピンし始めるとタイムスライスを使い切るまでスピンし続けることになるのである。 スピンロックを正しく実装することは難しい。なぜなら、競合状態を避けるためにロックの同時アクセスの可能性を考慮しなければならないからである。一般に、これは特別なアセンブリ言語の命令（アトミックなテスト・アンド・セット操作など）を使う必要があり、高級言語やアトミック命令をサポートしていない言語では簡単には実装できない。アトミック命令をサポートしないアーキテクチャや、高級言語で実装しなければならない場合、ピーターソンのアルゴリズムといったアトミックでないロックアルゴリズムを用いることができるかもしれない。ただし、スピンロックより多くのメモリが必要になるかもしれないし、アウト・オブ・オーダー実行が許される場合は高級言語では実装できないかもしれない。
rdf:langString
In informatica uno spinlock o anche spinning è una tecnica di programmazione che utilizza un ciclo di attesa attiva (busy waiting) per implementare la routine di attesa di un lock. La tecnica consiste nel verificare periodicamente se il lock è stato sbloccato, effettuando un test che può aver luogo ad intervalli di tempo prestabiliti, oppure nel tempo più breve possibile consentito dal sistema.
rdf:langString
Spinlock (wirująca blokada) – sposób realizacji synchronizacji międzyprocesowej, w którym oczekiwanie na zwolnienie blokady polega na ciągłym badaniu jej stanu. Spinlock działa więc na zasadzie aktywnego oczekiwania, tj. zużywa czas procesora, wykonując cały czas pustą pętlę: while blokada aktywna do {nic nie rób}; W systemach operacyjnych z podziałem czasu, ten rodzaj synchronizacji na poziomie aplikacji jest zwykle nieefektywny, lepiej sprawdzają się systemowe obiekty synchronizujące, jak muteksy. Z kolei w systemach wieloprocesorowych spinlock może być bardziej efektywny, ponieważ pętla wykonuje się w kontekście procesu - unika się kosztownego czasowo wstrzymania procesu i przełączenia kontekstu na kod systemowy. W systemie Windows NT sekcje krytyczne na maszynach wieloprocesorowych używają podejścia mieszanego: najpierw określoną liczbę razy sprawdza się, czy blokada została zwolniona, dopiero jeśli w tym czasie się nie zwolni, realizowany jest systemowy kod synchronizacji.
rdf:langString
Спин-блокировка или спинлок (англ. spinlock — циклическая блокировка) — низкоуровневый примитив синхронизации, применяемый в многопроцессорных системах для реализации взаимного исключения исполнения критических участков кода с использованием цикла активного ожидания. Применяется в случаях, когда ожидание захвата блокировки предполагается недолгим либо если контекст выполнения не позволяет переходить в заблокированное состояние. Спин-блокировки являются аналогами мьютексов, позволяющими тратить меньше времени на процедуру блокировки потока, поскольку не требуется переводить поток в заблокированное состояние. В случае мьютексов может потребоваться задействование планировщика с переводом потока в другое состояние и добавлением его в список потоков, ожидающих разблокировки. Спин-блокировки не задействуют планировщик и используют цикл активного ожидания без изменения состояния потока, что приводит к трате процессорного времени на ожидание освобождения блокировки другим потоком. Типовой реализацией спин-блокировки является простая циклическая проверка переменной спин-блокировки на доступность.
rdf:langString
自旋锁是计算机科学用于多线程同步的一种锁，线程反复检查锁变量是否可用。由于线程在这一过程中保持执行，因此是一种忙等待。一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁。 自旋锁避免了进程上下文的调度开销，因此对于线程只会阻塞很短时间的场合是有效的。因此操作系统的实现在很多地方往往用自旋锁。Windows操作系统提供的轻型读写锁（SRW Lock）内部就用了自旋锁。显然，单核CPU不适于使用自旋锁，这里的单核CPU指的是单核单线程的CPU，因为，在同一时间只有一个线程是处在运行状态，假设运行线程A发现无法获取锁，只能等待解锁，但因为A自身不挂起，所以那个持有锁的线程B没有办法进入运行状态，只能等到操作系统分给A的时间片用完，才能有机会被调度。这种情况下使用自旋锁的代价很高。 获取、释放自旋锁，实际上是读写自旋锁的存储内存或寄存器。因此这种读写操作必须是原子的。通常用test-and-set等原子操作来实现。
xsd:nonNegativeInteger
14604