08/10/2018

CAPÍTULO III
CONTROL DE LA CONCURRENCIA

1
 08/10/2018

GENERALIDADES

• Los sistemas de bases de datos se clasifican en:

• Monousuario
• Multiusuario

• Multiprogramación:
• Procesamiento simultáneo
(paralelo) de transacciones
• Ejecución concurrente intercalada

GENERALIDADES

• Razones para permitir la concurrencia:

• Aumentar la productividad:
• Número de transacciones ejecutadas por minuto.
• Aumentar la utilización de la CPU
• Menos tiempo ocioso y Control del disco.
• Reducir el tiempo medio de respuesta de transacciones
• Las ‘pequeñas’ no esperan a las ‘grandes’.

2
 08/10/2018

GENERALIDADES

• Mecanismo de control.
• Permite controlar la interacción entre los usuarios.
• Garantizar que la ejecución concurrente de transacciones no
resulta en una perdida de consistencia de la base de datos.
• La concurrencia se da cuando dos transacciones están
interconectadas.

PLANIFICACIÓN
(PROBLEMAS DE LA CONCURRENCIA)

• Pueden surgir problemas si las transacciones concurrentes se ejecutan de

manera no controlada.
• Una transacción correcta por sí misma puede producir una respuesta incorrecta
si alguna otra transacción interfiere con ella en alguna forma.
• Actualización Perdida
• Intercalación de operaciones
• Actualización Temporal o Lectura Sucia
• El Resumen Incorrecto
• La lectura no Repetible

3
 08/10/2018

LECTURA/ ESCRITURA

• LEER(X), o LEER(X), implica:

• - localizar el bloque en el que está almacenado X en la BD (si no está ya en el búfer de RAM
intermedio)
• - copiar el bloque en el búfer de memoria RAM intermedio (si no estaba ya allí)
• - copiar el valor de X en una variable de programa (espacio RAM privado de la transacción T)
• ESCRIBIR(X), o ESCRIBIR(X), supone:
• - localizar el bloque en el que está almacenado X en la BD (si no está ya en el búfer de RAM
intermedio)
• - copiar el bloque en el búfer de memoria RAM intermedio (si no estaba ya allí)
• - copiar el valor de la variable X (RAM local a T) en el lugar correcto dentro del búfer
• - transferir el bloque desde el búfer al disco (ya sea de inmediato o en algún momento
posterior; el mecanismo de recuperación o el SO se encargarán de ello)

PROBLEMAS DE LA CONCURRENCIA
(La actualización perdida)

T1: Transacción 1 T2: Transacción 2

• LEER(X);

• T1 y T2 que acceden a los • X:= X-N;

mismos datos • LEER(X);

•
•
X:= X+M;
Intercalan operaciones • ESCRIBIR(X);
generando errores. • LEER(Y);
• ESCRIBIR(X);
• Y:=Y+N;
• ESCRIBIR(Y);

4
 08/10/2018

PROBLEMAS DE LA CONCURRENCIA
(La actualización perdida) EJEMPLO

T1: Transacción 1 T2: Transacción 2

• LEER(X); • LEER(100);
• X = 100 • X:= X-N; • X:= 100-60;
• •
• Y= 80 •
LEER(X);
X:= X+M; •
LEER(100);
X:= 100+50;

• N = 60 • ESCRIBIR(X); • ESCRIBIR(40);
• LEER(Y); • LEER(80);
• M = 50 • ESCRIBIR(X); • ESCRIBIR(150);
• Y:=Y+N; • Y:=80+60;
• ESCRIBIR(Y); • ESCRIBIR(140); •

T1 y T2 que acceden a los mismos datos, tienen sus operaciones intercaladas de modo que
hacen incorrecto el valor de algún dato.

PROBLEMAS DE LA CONCURRENCIA
(La actualización perdida) EJEMPLO

T1: Transacción 1 T2: Transacción 2

• LEER(X); • LEER(100);

• X = 100 • X:= X-N; • X:= 100-60;

• ESCRIBIR(X); • ESCRIBIR(40);
• Y= 80 • LEER(X); • LEER(40);

• N = 60 • X:= X+M; • X:= 40+50;

• ESCRIBIR(X); • ESCRIBIR(90);
• M = 50 • LEER(Y); • LEER(80);
• Y:=Y+N; • Y:=80+60;
• ESCRIBIR(Y); • ESCRIBIR(140);

T1 y T2 que acceden a los mismos datos, tienen sus operaciones intercaladas de modo que hacen
incorrecto el valor de algún dato.

5
 08/10/2018

PROBLEMAS DE LA CONCURRENCIA
(Intercalación de Operaciones)

Transacción T1 Transacción T2

• LEER(X); • LEER(X);
• X:= X-N; • X:= X+M;
resultado incorrecto, • ESCRIBIR(X); • ESCRIBIR(X);

debido a la intercalación • LEER(Y);

de sus operaciones • Y:=Y+N;

• ESCRIBIR(Y);

PROBLEMAS DE LA CONCURRENCIA
(Intercalación de Operaciones) EJEMPLO

Transacción T1 Transacción T2

• • • •
• X = 100
LEER(X); LEER(100); LEER(X); LEER(100);
• X:= X+M; • X:= 100+50; • X:= X-N; • X:= 100-60;
• Y= 80 • ESCRIBIR(X); • ESCRIBIR(150); • ESCRIBIR(X); • ESCRIBIR(40);

• N = 60 • LEER(Y); • LEER(80);
• •
• M = 50 •
Y:=Y+N;
ESCRIBIR(Y); •
Y:=80+60;
ESCRIBIR(140);

resultado incorrecto, debido a la intercalación de sus operaciones

6
 08/10/2018

PROBLEMAS DE LA CONCURRENCIA
(Intercalación de Operaciones) EJEMPLO

T1: Transacción 1 T2: Transacción 2

• LEER(X); • LEER(100);
• X = 100 • X:= X-N; • X:= 100-60;
• •
• Y= 80 ESCRIBIR(X); ESCRIBIR(40);
• LEER(X); • LEER(40);

• N = 60 • X:= X+M; • X:= 40+50;

• ESCRIBIR(X); • ESCRIBIR(90);
• M = 50 • LEER(Y); • LEER(80);
• Y:=Y+N; • Y:=80+60;
• ESCRIBIR(Y); • ESCRIBIR(140);

resultado incorrecto, debido a la intercalación de sus operaciones

PROBLEMAS DE LA CONCURRENCIA
(actualización temporal o lectura sucia)

T1: Transacción 1 T2: Transacción 2

• LEER(X);
T1 actualiza un elemento X de • X:= X-N;

la BD y luego falla, pero antes • ESCRIBIR(X);

de que se restaure el valor • LEER(X);

original de X, T2 tiene acceso • X:= X+M;

al «valor temporal» de X • ESCRIBIR(X);

• LEER(Y);
• … •

7
 08/10/2018

PROBLEMAS DE LA CONCURRENCIA
(actualización temporal o lectura sucia) EJEMPLO

T1: Transacción 1 T2: Transacción 2

• LEER(X); • LEER(100);
• X = 100 • X:= X-N; • X:= 100-60;

• Y= 80 • ESCRIBIR(X); • ESCRIBIR(40);
• LEER(X); • LEER(40);
• N = 60 • X:= X+M; • X:= 40+50;

• M = 50 • LEER(Y); • LEER(80);
• ESCRIBIR(X); • ESCRIBIR(90);

• … • … • •

T1 actualiza un elemento X de la BD y luego falla, pero antes de que se restaure el

valor original de X, T2 tiene acceso al «valor temporal» de X

PROBLEMAS DE LA CONCURRENCIA
(El resumen incorrecto)

T1: Transacción 1 T2: Transacción 2

• suma:=0;

Otra transacción T2 calcula una función

• LEER(A);
agregada de resumen sobre varios registros • suma:= suma+A;
(suma las plazas reservadas para todos los • LEER(X);
vuelos), mientras otras transacciones, como • X:= X-N;
T1, actualizan dichos registros: puede que T2 • ESCRIBIR(X);
considere unos registros antes de ser • LEER(X);
actualizados y otros después • suma:= suma+X;
• LEER(Y);
• Y:= suma+Y;
• LEER(Y);
• Y:=Y+N;
• ESCRIBIR(Y); •

8
 08/10/2018

PROBLEMAS DE LA CONCURRENCIA
(El resumen incorrecto) EJEMPLO

T1: Transacción 1 T2: Transacción 2

• suma:=0; • suma:=0;
• X = 100 • LEER(A); • LEER(120);
• suma:= suma+A; • suma:= suma+120;
• Y= 80 • LEER(X); • LEER(100);
• X:= X-N; • X:= 100-600;
• N = 60 • ESCRIBIR(X); • ESCRIBIR(40);
• •
• M = 50 •
LEER(X);
suma:= suma+X; •
LEER(40);
suma:= suma+40;

• A = 120 • LEER(Y); • LEER(80);

• Y:= suma+Y; • Y:= suma+80;
• LEER(Y); • LEER(80);
• Y:=Y+N; • Y:=80+60;
•
• ESCRIBIR(Y); • ESCRIBIR(140); •

Otra transacción T2 calcula una función agregada de resumen sobre varios registros (suma las plazas
reservadas para todos los vuelos), mientras otras transacciones, como T1, actualizan dichos registros:
puede que T2 considere unos registros antes de ser actualizados y otros después

PROBLEMAS DE LA CONCURRENCIA
(El resumen incorrecto) EJEMPLO

T1: Transacción 1 T2: Transacción 2

• suma:=0; • suma:=0;

• X = 100 •
•
LEER(A);
suma:= suma+A;
•
•
LEER(120);
suma:= suma+120;
• •
• Y= 80 •
LEER(X);
X:= X-N; •
LEER(100);
X:= 100-600;
• •
•
ESCRIBIR(X); ESCRIBIR(40);
N = 60 • LEER(X); • LEER(40);
• suma:= suma+X; • suma:= suma+40;
• M = 50 • ESCRIBIR (X); • ESCRIBIR (40);
• LEER(Y); • LEER(80);

• A = 120 •
•
Y:= suma+Y;
ESCRIBIR (Y);
•
•
Y:= suma+80;
ESCRIBIR (240)
• LEER(Y); • LEER(240);
• Y:=Y+N; • Y:=240+60;
• ESCRIBIR(Y); • ESCRIBIR(300); • •

Otra transacción T2 calcula una función agregada de resumen sobre varios registros (suma las plazas reservadas para todos los vuelos),
mientras otras transacciones, como T1, actualizan dichos registros: puede que T2 considere unos registros antes de ser actualizados y otros
después

9
 08/10/2018

PROBLEMAS DE LA CONCURRENCIA
(La lectura no repetible)

T1: Transacción 1 T2: Transacción 2

• LEER(X); •
T2 lee un elemento X dos veces y otra • X:= X-N; •
transacción, como T1, modifica dicho X • • LEER(X);
entre las dos lecturas: T2 recibe • ESCRIBIR(X); •
diferentes valores para el mismo • LEER(Y); •
elemento. • •
• • LEER(X);
• •
• Y:=Y+N; •
• ESCRIBIR(Y); •

Planificación de transacciones

• Cada transacción comprende una secuencia de operaciones que

incluyen acciones de lectura y escritura en la BD, que finaliza con una
confirmación (COMMIT) o anulación (ROLLBACK)

• Una planificación P de n transacciones concurrentes T1, T2 ... Tn es una

secuencia de las operaciones realizadas por dichas transacciones, sujeta
a la restricción de que para cada transacción Ti que participa en P, sus
operaciones aparecen en P en el mismo orden en el que ocurren en Ti

10
 08/10/2018

PLANIFICACIÓN / SERIABILIDAD
MOTIVACIÓN

TRANSACCIÓN 1 TRANSACCIÓN 2 TRANSACCIÓN 1 TRANSACCIÓN 2

• Objetivo de un protocolo de
• LEER(X); • LEER(X);

•
control de concurrencia:
Planificar las transacciones de
• X:= X-N; • X:= X+M;
forma que no ocurran
interferencias entre ellas, y así • ESCRIBIR(X); • ESCRIBIR(X);
evitar la aparición de los
problemas mencionados
• LEER(Y); • LEER(X);
• Solución obvia: no permitir
intercalación de
operaciones de varias
• Y:=Y+N; • X:= X-N;
transacciones
• ESCRIBIR(Y); • ESCRIBIR(X);
• LEER(X); • LEER(Y);
• X:= X+M; • Y:=Y+N;
• ESCRIBIR(X); • ESCRIBIR(Y);

B
PLANIFICACIÓN: A PLANIFICACIÓN:

SERIALIZABILIDAD

• Pero el objetivo de un SGBD

• LEER(X); • LEER(X);
multiusuario también es
maximizar el grado de • X:= X-N; • X:= X-N;
concurrencia del sistema
• Si se permite la • LEER(X); • ESCRIBIR(X);
intercalación de
operaciones, existen • X:= X+M; • LEER(X);
muchos órdenes posibles de
ejecución de las • ESCRIBIR(X);
• X:= X+M;
transacciones
• LEER(Y);
• ESCRIBIR(X);
• ESCRIBIR(X); • LEER(Y);
• Y:=Y+N;
• Y:=Y+N;
• ESCRIBIR(Y);
• ESCRIBIR(Y);

PLANIFICACIÓN: actualización perdida! PLANIFICACIÓN: Correcta!

11
 08/10/2018

SERIALIZABILIDAD
PLANIFICACIÓN DE TRANSACCIONES

• Para el control de la concurrencia (y recuperación de fallos)

interesa prestar mayor atención a estas operaciones:

operación abreviatura
LEER l
ESCRIBIR e
COMMIT c
ROLLBACK r

SERIALIZABILIDAD
PLANIFICACIÓN DE TRANSACCIONES (EJEMPLO)

T1 T2

• T1: LEER(X) •
• T1: LEER(X)
• T1: ESCRIBIR(X) •
• T1: ESCRIBIR(X)
• T1: LEER(Y) •
• T1: LEER(Y)
• T1: COMMIT •
• T1: COMMIT • • T2: LEER(X)

• T2: LEER(X) • • T2: ESCRIBIR(X)

• T2: ESCRIBIR(X) • • T2: COMMIT

• T2: COMMIT

El subíndice de cada operación indica la transacción que la realiza PA: l1(X) ; e1(X) ; l1(Y) ; e1(Y) ; c1 ; l2(X) ; e2(X) ; c2 ;

12
 08/10/2018

• T1: LEER(X)
• T1: ESCRIBIR(X) •
• T1: LEER(Y) •
• T1: ESCRIBIR(Y) •
SERIALIZABILIDAD • T1: COMMIT •
•
• T2: LEER(X)
PLANIFICACIÓN SERIE • T2: ESCRIBIR(X) •
• T2: COMMIT •
• •
• • T2: LEER (X)
Una planificación serie P es aquella en la que las operaciones de
• • T2: ESCRIBIR (X)
cada transacción se ejecutan consecutivamente sin que se
intercalen operaciones de otras transacciones • • T2: COMMIT
• • T1: LEER (X)
PA: l1(X) ; e1(X) ; l1(Y) ; e1(Y) ; c1 ; l2(X) ; e2(X) ; c2 ;
• • T1: ESCRIBIR (X)
• A PB: l2(X) ; e2(X) ; c2 ; l1(X) ; e1(X) ; l1(Y) ; e1(Y) ; c1 ;
• • T1: LEER (Y)
• • T1: ESCRIBIR (Y)
• T1: COMMIT

SERIALIZABILIDAD
PLANIFICACIÓN NO SERIE

• Una planificación no serie P es aquella en la que las operaciones de un

conjunto de transacciones concurrentes se ejecutan intercaladas
PC: l1(X) ; l2(X) ; e1(X) ; l1(Y) ; e2(X) ; c2 ; e1(Y) ; c1 ;
PD: l1(X) ; e1(X) ; l2(X) ; e2(X) ; c2 ; l1(Y) ; e1(Y) ; c1 ;

• Hemos de determinar qué planificaciones no serie permiten llevar la

BD a un estado al que pueda llegarse mediante una ejecución en
serie

13
 08/10/2018

SERIALIZABILIDAD
PLANIFICACIÓN SERIALIZABLE

• Una planificación P (no serie) es serializable si es equivalente a alguna

planificación serie de las mismas n transacciones
• Una planificación que no es equivalente a ninguna ejecución en serie, es una
planificación no serializable
• Toda planificación serializable es correcta
• Produce los mismos resultados que alguna ejecución en serie
• Dos maneras de definir la equivalencia entre planificaciones:
• Equivalencia por conflictos
• Equivalencia de vistas

SERIALIZABILIDAD
EQUIVALENCIA POR CONFLICTOS

• Si solo se lee un elemento no

hay conflictos.
• Si se leen o escriben elementos
independientes no hay conflicto
• Cuando existe escritura por parte
de una transacción que es leida
por una segunda transacción

14
 08/10/2018

SERIALIZABILIDAD
EQUIVALENCIA POR CONFLICTOS

T1: TRANSACCIÓN 1 T2: TRANSACCIÓN 2 T1: TRANSACCIÓN 1 T2: TRANSACCIÓN 2

T1: LEER(X) T1: LEER(X)

T2: LEER(X) T1: ESCRIBIR(X)
T1: ESCRIBIR(X) T2: LEER(X)
T1: LEER(Y) T2: ESCRIBIR(X)
T2: ESCRIBIR(X) T2: COMMIT
T2: COMMIT T1: LEER(Y)
T1: ESCRIBIR(Y) T1: ESCRIBIR(Y)
T1: COMMIT T1: COMMIT

Operaciones en conflicto en las planificaciones PC y PD:

PC: l1(X) ; l2(X) ; e1(X) ; l1(Y) ; e2(X) ; c2 ; e1(Y) ; c1; PD: l1(X) ; e1(X) ; l2(X) ; e2(X) ; c2 ; l1(Y) ; e1(Y) ; c1;

SERIALIZABILIDAD
DETECCIÓN DE LA SERIALIZABILIDAD POR CONFLICTOS (GRAFOS)

N es un conjunto de nodos
grafo dirigido G = ( N, A ) A es un conjunto de aristas
dirigidas

• Algoritmo:
• Crear un nodo por cada transacción Ti en P
• Crear una arista Tj Tk si Tk lee el valor de un elemento después de que Tj lo
haya escrito
• Crear una arista Tj Tk si Tk escribe el valor de un elemento después de que Tj
lo haya leído
• Crear una arista Tj Tk si Tk escribe el valor de un elemento después de que Tj
lo haya escrito

15
 08/10/2018

SERIALIZABILIDAD
DETECCIÓN DE LA SERIALIZABILIDAD POR CONFLICTOS (Y 2)

• Una arista Tj  Tk indica que Tj debe aparecer antes que Tk en una planificación serie
equivalente a P, pues dos operaciones en conflicto aparecen en dicho orden en P
• Si el grafo contiene un ciclo, P no es serializable por conflictos
• Un ciclo es una secuencia de aristas C=((Tj Tk), (Tk Tp),... (Ti Tj))
• Si no hay ciclos en el grafo, P es serializable
Es posible obtener una planificación serie S equivalente a P, mediante una
ordenación topológica de los nodos

SERIALIZABILIDAD
EJEMPLO DE PLANIFICACIÓN NO SERIALIZABLE

LEER(X); LEER(Z); LEER(Y);

ESCRIBIR(X); LEER(Y); LEER(Z);
LEER(Y); ESCRIBIR(Y); ESCRIBIR(Y);
ESCRIBIR(Y); LEER(X); ESCRIBIR(Z);
ESCRIBIR(X);

LEER(Z);
LEER(Y);
Hay dos ciclos:
ESCRIBIR(Y); T1→T2→T1 y T1→T2→T3→T1
LEER(Y);
LEER(Z); Y
LEER(X);
ESCRIBIR(X); T1 T2
ESCRIBIR(Y);
X
ESCRIBIR(Z);
LEER(X); Y Y,Z
LEER(Y);
ESCRIBIR(Y);
ESCRIBIR(X);
T3
PLANIFICACIÓN E

16
 08/10/2018

SERIALIZABILIDAD
EJEMPLO DE PLANIFICACIÓN SERIALIZABLE

LEER(X); LEER(Z); LEER(Y);

ESCRIBIR(X); LEER(Y); LEER(Z);
LEER(Y); ESCRIBIR(Y); ESCRIBIR(Y);
ESCRIBIR(Y); LEER(X); ESCRIBIR(Z);
ESCRIBIR(X);

LEER(Y);
LEER(Z); La planificación serie equivalente es T3 → T1 →
LEER(X); T2
ESCRIBIR(X);
ESCRIBIR(Y);

LEER(Z);
ESCRIBIR(Z);
T1 T2
LEER(Y); X,Y
ESCRIBIR(Y);
LEER(Y); Y Y,Z
ESCRIBIR(Y);
LEER(X);
ESCRIBIR(X);
T3
Planificación F

PROTOCOLOS DE BLOQUEO
DEFINICIONES

• PROTOCOLO
• Conjunto de reglas que garantizan la serialización.
• BLOQUEO
• Conjunto de herramientas que impiden acceso concurrente a los datos.
• MARCAS TEMPORALES
• Una marca de tiempo es un identificador único generado por el sistema para cada transacción.
• MULTIVERSIÓN
• Utilizan varias versiones de un elemento de datos.
• GRANULARIDAD
• Porción de la base de datos es representada por un elemento de datos

17
 08/10/2018

PROTOCOLOS DE BLOQUEO

• Una de las propiedades fundamentales de las transacciones es el aislamiento.

• Es necesario que el sistema controle la interacción entre las transacciones
concurrentes.
• Existen muchos modos mediante los cuales se puede bloquear un elemento de
datos.
1. Compartido. Si una transacción Ti obtiene un bloqueo en modo compartido
(denotado por C) sobre el elemento Q, entonces T puede leer Q pero no lo puede
i

escribir.
2. Exclusivo. Si una transacción T obtiene un bloqueo en modo exclusivo (denotado
i

por X) sobre el elemento Q, entonces T puede tanto leer como escribir Q.

i

Técnicas de control de concurrencia

• Métodos basados en la teoría de la serializabilidad, que definen un conjunto de

reglas (o protocolo) tal que si todas las transacciones las cumplen, o el
subsistema de control de concurrencia del SGBD las impone
(automáticamente) se asegura la serializabilidad de toda planificación de
transacciones

• Clasificación
• Métodos de bloqueo
• Métodos de marca de tiempo
• Técnicas de multiversión
• Métodos optimistas

18
 08/10/2018

PROTOCOLOS DE BLOQUEO

SOLICITA GESTOR DE CONTROL DE

BLOQUEO CONCURRENCIA

REALIZA OTORGA
TRANSACCIÓN BLOQUEO

• Es necesario que toda transacción solicite un bloqueo del modo apropiado

sobre el elemento de datos Q dependiendo de los tipos de operaciones que se
vayan a realizar sobre Q. La petición se hace al gestor de control de
concurrencia. La transacción puede realizar la operación sólo después de que el
gestor de control de concurrencia conceda el bloqueo a la transacción

PROTOCOLOS DE BLOQUEO
FUNCIÓN DE COMPATIBILIDAD

A Ti
A

B Tj
Ti
GESTOR DE
Ti ≠ Tj CONTROL DE
CONCURRENCIA
Tj
A Ti

B
B Tj

19
 08/10/2018

PROTOCOLOS DE BLOQUEO
FUNCIÓN DE COMPATIBILIDAD

PROTOCOLOS BASADOS EN BLOQUEO

• BLOQUEOS BINARIOS
• BLOQUEOS COMPARTIDOS/EXCLUSIVOS

20
 08/10/2018

PROTOCOLOS BASADOS EN
BLOQUEO (BINARIOS)

• Tiene dos estados o valores:

• Bloqueado (1)
• No podrá ser accedido.
• Se requiere de la instrucción BLOQUEAR (X)
• Desbloqueado (O).
• Podrá ser accedido.
• Se requiere de la instrucción DESBLOQUEAR (X)
• Un bloqueo binario impone la exclusión mutua en el elemento de datos.
• Las operaciones BLOQUEAR y DESBLOQUEAR deben implementarse como
unidades indivisibles

PROTOCOLOS BASADOS EN
BLOQUEO (BINARIOS)

• Cuando una transacción T solicita un bloqueo

• Si el elemento no ha sido ya bloqueado por otra transacción, se le concede el
bloqueo
• Si el elemento sí está bloqueado, el SGBD determina si la solicitud es
compatible con el bloqueo existente:
• Si se pide un bloqueo compartido sobre un elemento que ya tiene un bloqueo
compartido, el bloqueo será concedido a T
• En otro caso, T debe esperar hasta que se libere el bloqueo existente
• Una transacción que obtiene un bloqueo lo mantiene hasta que lo libera
explícitamente o termina (COMMIT o ROLLBACK)
• Sólo cuando se libera un bloqueo exclusivo los efectos de la escritura serán visibles
para las demás transacciones

21
 08/10/2018

PROTOCOLOS BASADOS EN
BLOQUEO (BINARIOS)

T1: TRANSACCIÓN 1 T2: TRANSACCIÓN 2

• BLOQUEAR(X)
Una transacción T debe emitir la
• Leer (X)
operación bloquear(X) antes de que se • X:= X + 50
ejecute cualquier operación leer (X) o
escribir(X) en T.
• Escribir (X)
• DESBLOQUEAR(X)
• BLOQUEAR (X)
• …..

PROTOCOLOS BASADOS EN
BLOQUEO (BINARIOS)

1. Una transacción T debe emitir la operación bloquear (X) antes de que

se ejecute cualquier operación leer(X) o escribir(X) en T.
2. Una transacción T debe emitir la operación desbloquear elemento(X)
después de haberse completado todas las operaciones leer (X) y
escribir(X) de T.
3. Una transacción T no emitirá una operación bloquear(X) si ya posee el
bloqueo del elemento x1.
4. Una transacción T no emitirá una operación desbloquear(X) a menos
que ya posea el bloqueo del elemento X.

22
 08/10/2018

PROTOCOLOS BASADOS EN
BLOQUEO (COMPARTIDOS/EXCLUSIVOS)

• Si una transacción va a escribir un elemento X, debe tener acceso

exclusivo a X. Para ello se utiliza un tipo de bloqueo diferente
denominado bloqueo de modo múltiple.

PROTOCOLOS BASADOS EN
BLOQUEO (COMPARTIDOS/EXCLUSIVOS)

REGLAS
1. Una transacción T debe emitir la operación bloquea_Lectura(X) o bloquear_escritura(X) antes de
que se ejecute cualquier operación LEER(X) de T
2. Una transacción T debe emitir la operación bloquear_escritura(X) antes de que se ejecute cualquier
operación ESCRIBIR(X) de T
3. Una transacción T debe emitir la operación desbloquear(X) una vez que se hayan completado todas
las operaciones LEER(X) y ESCRIBIR(X) de T3
4. Una transacción T no emitirá una operación Bloquea_Lectura(X) si ya posee un bloqueo de lectura
(compartido) o de escritura (exclusivo) para el elemento X Esta regla se puede hacer menos estricta,
como veremos en breve.
5. Una transacción T no emitirá una operación bloquear_escritura(X) si ya posee un bloqueo de lectura
(compartido) o de escritura (exclusivo) para el elemento X Esta regla se puede hacer menos estricta.
6. Una transacción T no emitirá una operación desbloquear(X) a menos que ya posea un bloqueo de
lectura (compartido) o de escritura (exclusivo) sobre el elemento X

23
 08/10/2018

PROTOCOLOS BASADOS EN BLOQUEO

(COMPARTIDOS/EXCLUSIVOS)

T1: TRANSACCIÓN 1 T2: TRANSACCIÓN 2 T1: TRANSACCIÓN 1 T2: TRANSACCIÓN 2

Bloquear-C (Y); Bloquear-C(Y);

leer (Y); leer (Y);

Desbloquear(Y); Desbloquear (Y);

Bloquear-X (X); Bloquear-C(X);

leer (X); Leer (X);
X:=X+Y; Desbloquear (X);
escribir (X); Bloquear- X(Y);
desbloquear(X); Leer (Y);
Bloquear- C(X); Y:=X+Y;
Leer (X); Escribir (Y);
Desbloquear(X); Desbloquear (Y);
Bloquear- X(Y); Bloquear- X(X);

Leer (Y); Leer (X);

Y:=X+Y; X:=X+Y;
Escribir (Y); Escribir (X);
Desbloquear (Y); Desbloquear (X);

• A • B

El uso de bloqueos para la programación de transacciones no garantiza la

serializabilidad de las planificaciones.

PROTOCOLOS BASADOS EN
BLOQUEO (BLOQUEO DE DOS FASES)

REGLAS
1. Una transacción T debe emitir la operación Bloquea_Lectura(X) o
bloquear_escritura(X) antes de que se ejecute cualquier operación
LEER(X) de T
2. Una transacción T debe emitir la operación bloquear_escritura(X) antes
de que se ejecute cualquier operación ESCRIBIR(X) de T
3. Una transacción T debe emitir la operación desbloquear(X) una vez que
se hayan completado todas las operaciones LEER(X) y ESCRIBIR(X) de
T3.

24
 08/10/2018

PROTOCOLOS BASADOS EN
BLOQUEO (BLOQUEO DE DOS FASES)

4. Una transacción T no emitirá una operación Bloquea_Lectura(X) si ya posee

un bloqueo de lectura (compartido) o de escritura (exclusivo) para el
elemento X Esta regla se puede hacer menos estricta, como veremos en
breve.
5. Una transacción T no emitirá una operación bloquear_escritura(X) si ya posee
un bloqueo de lectura (compartido) o de escritura (exclusivo) para el
elemento X Esta regla se puede hacer menos estricta, como veremos en
breve.
6. Una transacción T no emitirá una operación desbloquear(X) a menos que ya
posea un bloqueo de lectura (compartido) o de escritura (exclusivo) sobre el
elemento X

25