operating-system - meaning - semaphore light
Diferencia entre contar y semáforos binarios (3)
En realidad, ambos tipos se usan para sincronizar el acceso a un recurso compartido, ya sea que la entidad que intenta acceder sea un proceso o incluso un subproceso.
La diferencia es la siguiente:
Los semáforos binarios son binarios, solo pueden tener dos valores; uno para representar que un proceso / hilo está en la sección crítica (código que accede al recurso compartido) y otros deben esperar, el otro que indica que la sección crítica es gratis.
Por otro lado, los semáforos de recuento toman más de dos valores, pueden tener cualquier valor que desee. El valor máximo que toman X permite a los procesos / subprocesos X acceder al recurso compartido simultáneamente.
Para más información, eche un vistazo a este enlace.
http://www.chibios.org/dokuwiki/doku.php?id=chibios:articles:semaphores_mutexes
EDITAR
El valor máximo que puede tomar un semáforo de recuento es el número de procesos que desea permitir en la sección crítica al mismo tiempo.
Una vez más, es posible que tenga un caso en el que desee la exclusión de un determinado recurso, pero sabe que se puede acceder a este mediante un número máximo de procesos (por ejemplo, X), por lo que establece un semáforo de conteo con el valor X.
Esto permitiría a los procesos X acceder a ese recurso al mismo tiempo; sin embargo, el proceso X + 1 tendría que esperar hasta que uno de los procesos en la sección crítica salga.
¿Cuál es la diferencia entre contar y el semáforo binario?
Lo que he visto en algún lugar es que ambos pueden controlar el número de procesos que han solicitado un recurso. Ambos han tomado y estados libres.
¿Hay alguna restricción sobre cuántos recursos pueden proteger un semáforo binario y un semáforo de conteo?
Ambos permiten que solo un proceso use un recurso a la vez ...
¿Hay alguna otra diferencia? ¿Son correctas las propiedades antes mencionadas?
Hay dos conceptos esenciales para construir programas concurrentes: sincronización y exclusión mutua. Veremos cómo estos dos tipos de bloqueos (los semáforos son generalmente un tipo de mecanismo de bloqueo) nos ayudan a lograr la sincronización y la exclusión mutua.
Un semáforo tiene dos partes: un contador y una lista de tareas en espera para acceder a un recurso en particular. Un semáforo realiza dos operaciones: esperar (P) [esto es como adquirir un bloqueo] y liberar (V) [similar a liberar un bloqueo]: estas son las únicas dos operaciones que se pueden realizar en un semáforo. En un semáforo binario, el contador va lógicamente entre 0 y 1. Se puede pensar que es similar a un bloqueo con dos valores: abierto / cerrado. Un semáforo de conteo tiene múltiples valores para contar.
Lo que es importante comprender es que el contador de semáforos realiza un seguimiento del número de tareas que no tienen que bloquear, es decir, pueden avanzar. Las tareas se bloquean y se agregan a la lista del semáforo solo cuando el contador es cero. Por lo tanto, una tarea se agrega a la lista en la rutina P () si no puede progresar, y se "libera" usando la rutina V ().
Ahora, es bastante obvio ver cómo se pueden usar los semáforos binarios para resolver la sincronización y la exclusión mutua, esencialmente son bloqueos.
ex. Sincronización:
thread A{
semaphore &s; //locks/semaphores are passed by reference! think about why this is so.
A(semaphore &s): s(s){} //constructor
foo(){
...
s.P();
;// some block of code B2
...
}
//thread B{
semaphore &s;
B(semaphore &s): s(s){} //constructor
foo(){
...
...
// some block of code B1
s.V();
..
}
main(){
semaphore s(0); // we start the semaphore at 0 (closed)
A a(s);
B b(s);
}
En el ejemplo anterior, B2 solo puede ejecutarse después de que B1 haya finalizado la ejecución. Digamos que el hilo A viene primero se ejecuta: llega a sem.P () y espera, ya que el contador es 0 (cerrado). El subproceso B aparece, finaliza B1 y luego libera el subproceso A, que luego completa B2. Así logramos la sincronización.
Ahora veamos la exclusión mutua con un semáforo binario:
thread mutual_ex{
semaphore &s;
mutual_ex(semaphore &s): s(s){} //constructor
foo(){
...
s.P();
//critical section
s.V();
...
...
s.P();
//critical section
s.V();
...
}
main(){
semaphore s(1);
mutual_ex m1(s);
mutual_ex m2(s);
}
La exclusión mutua también es bastante simple: m1 y m2 no pueden ingresar a la sección crítica al mismo tiempo. Entonces, cada hilo está utilizando el mismo semáforo para proporcionar la exclusión mutua para sus dos secciones críticas. Ahora, ¿es posible tener mayor concurrencia? Depende de las secciones críticas. (Piense en cómo podría uno usar semáforos para lograr la exclusión mutua ... pista : ¿necesariamente solo necesito usar un semáforo?)
Contando el semáforo: un semáforo con más de un valor. Veamos lo que esto implica: ¿un bloqueo con más de un valor ? Tan abierto, cerrado, y ... hmm. ¿De qué sirve un bloqueo de varias etapas en la exclusión o sincronización mutua?
Tomemos el más fácil de los dos:
Sincronización utilizando un semáforo de recuento: Digamos que tiene 3 tareas: # 1 y 2 que desea ejecutar después de 3. ¿Cómo diseñaría su sincronización?
thread t1{
...
s.P();
//block of code B1
thread t2{
...
s.P();
//block of code B2
thread t3{
...
//block of code B3
s.V();
s.V();
}
Entonces, si tu semáforo comienza cerrado, te aseguras de que t1 y t2 bloqueen, se agreguen a la lista del semáforo. Luego viene todo t3 importante, termina su negocio y libera t1 y t2. ¿En qué orden son liberados? Depende de la implementación de la lista del semáforo. Podría ser FIFO, podría basarse en alguna prioridad particular, etc. ( Nota : piense cómo organizaría sus P y V; s si quisiera que t1 y t2 se ejecutaran en algún orden en particular, y si no estaba al tanto de la implementación del semáforo)
( Averigüe : ¿Qué sucede si el número de V es mayor que el número de P?)
Exclusión mutua mediante el uso de semáforos de conteo: me gustaría que construyas tu propio pseudocódigo para esto (¡ te hace entender mejor las cosas! ), Pero el concepto fundamental es este: un semáforo de conteo de contador = N permite que N tareas ingresen a la sección crítica libremente . Lo que esto significa es que tiene N tareas (o subprocesos, si lo desea) ingrese a la sección crítica, pero la N + 1a tarea se bloquea (entra en nuestra lista de tareas bloqueadas favoritas), y solo se deja pasar cuando alguien V es el semáforo al menos una vez. Así que el contador de semáforos, en lugar de oscilar entre 0 y 1, ahora va entre 0 y N, permitiendo que N tareas entren y salgan libremente, ¡sin bloquear a nadie!
Ahora, ¿por qué necesitarías una cerradura tan extraña? ¿No es el punto de exclusión mutua no permitir que más de un individuo acceda a un recurso? Pensar. ( Sugerencia ... No siempre tienes un solo disco en tu computadora, ¿verdad ...?)
Para pensar: ¿Se logra la exclusión mutua teniendo solo un semáforo de conteo? ¿Qué sucede si tiene 10 instancias de un recurso y entran 10 hilos (a través del semáforo de conteo) y trata de usar la primera instancia?
La diferencia más básica entre contar y el semáforo binario es que:
- El semáforo binario no puede manejar la espera limitada ya que es solo una variable que contiene valores binarios. Recuento de semáforos Puede manejar la espera limitada ya que ha convertido una variable en una estructura con una Cola.
Implementación de Strcuture Semáforo binario : int s;
Contando el semáforo : Struct S {int s; Cola q; }
El uso del proceso del semáforo de recuento ahora, una vez obtenido el CS (Sección crítica), ahora tiene que esperar al otro para obtener el CS, por lo que no es un proceso sencillo. Cada proceso tiene una oportunidad para CS.