Tranzakciók gyakorlati anyag

Tranzakciókgyakorlati anyag

PPKE-ITK, Database Systems, 2010.

Definíció: tranzakciók

Olyan program-végrehajtási egységek, amik az adatbázison valamilyen műveleteket végeznek.

olvasás: vö. SELECT, X: adattagon

read(X)

írás, törlés, módosítás: vö. INSERT, DELETE,

UPDATE

write(X)

2Database Systems - Tranzakciók (gyakorlat)

Pl. bank, wiki, jegyfoglalás, neptun, stb…

Elvárások tranzakciókezeléskor: ACID Atomosság (Atomicity)

A tranzakció vagy teljes egészében, vagy egyáltalán ne hajtódjon végre. – helyreállító egység (recovery manager)

Adatbázis helyessége (Consistency) (konzisztencia, következetesség) A tranzakció hatására az adatbázis a kezdeti konzisztens

állapotból egy másik konzisztens állapotba jut. – programozó feladata

Elkülönítés (Isolation) A tranzakció befejeződése után az adatbázis állapota csak

olyan lehet, mintha a tranzakció egyedül futott volna, nem párhuzamosan a többivel. – tranzakció kezelő (ütemező)

Tartósság(Durability) A tranzakció befejeződése után annak eredménye nem

veszhet el, be kell jegyezni az adatbázisba. – tranzakció kezelő (ütemező), helyreállító egység 3Database Systems - Tranzakciók

(gyakorlat)

Tranzakció példa – sörösüvegek x: kamrában lévő üvegek száma (adattag) y: hűtőben lévő üvegek száma (adattag) T1: a kamrából N db-ot átteszek a hűtőbe

(tranzakció) T2: apu hozott M db üveggel a kamrába

(tranzakció) T3: megiszunk O db üveggel a hűtőből

(tranzakció)

T1 T2 T3

read(x) read(x) read(y)

x:=x-N x:=x+M y:=y-O

write(x) write(x) write(y)

read(y)

y:=y+N

write(y)4Database Systems - Tranzakciók

(gyakorlat)

Ütemezés (Scheduling)

Olyan szekvenciák, amik megmutatják az időbeli sorrendjét az egyidejűleg futó tranzakciók műveleteinek

Soros ütemezés: egymás után futnak le a tranzakciók T1, T2, T6, T3, … az ilyen mindig konzisztens

Párhuzamos ütemezés: egyszerre több tranzakció fut párhuzamosan egy tranzakció egyik művelete megelőzhet, egy másik

művelete követheti egy másik tranzakció egy műveletét… 5Database Systems - Tranzakciók

(gyakorlat)

Ütemezés – példa

T1 T2 T3read(x) read(x) read(y)x:=x-N x:=x+M y:=y-Owrite(x) write(x) write(y)

read(y)

y:=y+N

write(y)

Mi lesz x és y, ha a kezdőértékek: x=15; y=5; N=5; M=10; O=2

a) Ha T1 lefut, majd T2 és T3? (soros ütemezés) T1 után x=10,y=10, T2 után x=20,y=10, T3 után

x=20,y=8

b) Ha T2 fut le először, majd T3 és végül T1? (soros)

T2 után x=25,y=5, T3 után x=25,y=3, T1 után x=20,y=8

c) Egyéb sorrendben, ahol egymás után futnak le a tranzakciók? (soros)

végül mindig: x=20,y=8

d) És ha párhuzamosan, akkor veszítünk adatot? lásd a következő ábrán: 6Database Systems - Tranzakciók

(gyakorlat)

Párhuzamos ütemezés – példaT1 T2 T3

read(x)

x:=x-N

read(x)

x:=x+M

write(x)

read(y)

write(x)

y:=y+N

read(y)

y:=y-O

write(y)

write(y)

Veszítünk adatot? igen veszítünk adatot, mivel az x és y

változok sem lesznek kiírva a következő olvasás előtt

x=25, y=3

Kezdőértékek:x=15; y=5; N=5; M=10; O=2


Konfliktus, ekvivalencia, sorosíthatóság

Conflicting tranzakciók: azok a tranzakciók, amelyek ugyanazon az adattagon

dolgoznak, és legalább az egyik írni szeretné

Ha egy S ütemezés átalakítható egy S’ ütemezésre non-conflicting műveletek cseréjével, akkor:

S és S’ konfliktus ekvivalens.

Két művelet non-conflicting: Ha különböző adattagon dolgoznak, vagy ha

ugyanazon, de mindkettő csak olvassa.

Ha egy S ütemezés konfliktus ekvivalens egy S’ soros ütemezéssel, akkor

az S ütemezés konfliktus sorosítható.


Konfliktus-ekvivalencia – példa Konfliktus-ekvivalens, konfliktus sorosítható:

T1 T2 T3read(x)write(x)

read(x)read(y)

write(x)write(y)

read(y)write(y)

T1 T2 T3read(x)write(x)read(y)write(y)

read(x)write(x)

read(y)write(y)


Database Systems - Tranzakciók (gyakorlat) 10

Nézet ekvivalencia – definíció Legyen S és S’ két ütemezés ugyanazon

tranzakciós műveletekkel. Ezek nézet ekvivalensek, ha: minden X adatelemre, ha Ti olvassa S-ben X-

kezdőértékét, akkor S’-ben is ugyanúgy kell olvasnia Ti-nek X kezdőértékét ÉS

minden X adatelemre, ha Ti S-ben olvassa X-et, amely X egy létező Tj tranzakciótól származik, akkor Ti-nek S’ ütemezésben ugyanúgy egy létező Tj által adott értéket kell olvasnia, ÉS

minden X adatelemre, ha egy tranzakció S-ben az utolsó write(X) utasítást hajtja végre, akkor S’-ben ugyancsak write(X)-et kell csinálnia.



Példa – Nézet ekvivalensek-e?

T1 T2 T3

read(X) 1

X:=X-N 2

3 read(X)

4 X:=X+M

write(X) 5

Read(Y) 6

7 write(X)

Y:=Y+N 8

write(Y) 9

read(y)

y:=y-O

write(y)13Database Systems - Tranzakciók

(gyakorlat)

T1 T2 T3

read(X) 1

X:=X-N 2

3 read(X)

4 X:=X+M

5 write(X)

write(X) 6

read(Y) 7

Y:=Y+N 8

write(Y) 9

read(y)

y:=y-O

write(y)

S ütemezés S’ ütemezés

Nem.

Nézet és konfliktus ekvivalencia

Ami konfliktus ekvivalens, az nézet ekvivalens is.

Ami nézet ekvivalens, az nem biztos, hogy konfliktus ekvivalens is. Pl.:

vakonírás


N-E.

K-E.

Sorosíthatóság eldöntése, biztosítása

megelőzési gráf (gyakorlatban nem alkalmas)

különböző protokollok

kétfázisú protokoll

időbélyegzési protokoll (timestamping)


Megelőzési (precedencia) gráf irányított gráf, melynek csúcsai maguk a

tranzakciók, élei: (~ a conflicting műveleteknél:)

TiTk között fut él, ha Ti ugyanazt az adatot írta, amit Tk olvasni fog

TiTk ---------------| | --------------- olvasta -----| |---- írni fog

TiTk ---------------| | --------------- írta -----| |---- írni fog

Példa (1):


T1 T2

read(A)

A := A – 50

write (A)

read(B)

B := B + 50

write(B)

read(A)

temp := A * 0.1

A := A – temp

write(A)

read(B)

B := B + temp

write(B)

A precedencia-gráfja:

Sorosítható-e? Sorosítható.

T1 T2A, B


Példák megelőzési gráfra (2)T1 T2 T3 T4

read(A)

read(B)

write(A)

read(C)

write(B)

read(C)

read(B)


T1 T2

T3 T4

Sorosítható-e?- Igen.

Ha a gráf körmentes, akkor sorosítható.

A

B

B


Példák megelőzési gráfra (3)


Nem körmentes, ezért nem sorosítható.

T1 T2

read(A)

A := A – 50

read(A)

temp := A * 0.1

A := A – temp

write(A)

read(B)

write (A)

read(B)

B := B + 50

write(B)

B := B + temp

write(B)

T1 T2

A, B

A, B



Döntse el a gráf alapján, hogy sorosítható-e? Ha igen, adjon meg legalább két sorrendet!

Sorosítható.

Megoldások pl:

T1-T2-T3-T4-T5-T6-T7

T1-T2-T3-T5-T4-T6-T7

T1 T2 T3

T4 T5 T6

T7



T1 T2 T3

T4 T5 T6

T7 T8

T9

Megoldás:Nem körmentes! T4-T5-(T3-T6-T8)-T7-T4

Zárolási technikák (Locking) Minden adatelemhez hozzárendelünk egy

állapotjelzőt, amivel megadjuk,hogy mire használhatjuk az adatot, vagy, hogy használhatjuk-e. lock(X): a tranzakció lock-ol egy adatot, így azt addig

nem érheti el semmilyen tranzakció unlock(X): lock feloldása

ha csak ezeket használjuk, nem lesz optimális a rendszerünk teljesítménye.

vezessünk be új lock-okat lock-x(X): exclusive lock : csak az adott tranzakció

által használható az adat, mindenki más számára hozzáférhetetlen

lock-s(X): shared lock: (~ read only) mindegyik tranzakció csak olvashatja őt. 23Database Systems - Tranzakciók

(gyakorlat)

Zárolási technikák (Locking) (folyt.)

és tételezzük fel ezekről a lockokról, hogy: a tranzakciónak kötelezően mindig küldenie kell

egy kérelmet (request), ha írni/olvasni akar egye adatelemet

ha már nincs szüksége az adatelemre, unlockolja

a tranzakció nem lockolja, ha már egyszer őnála van

ugyanígy, ne unlockolja, ha nincs nála


Példa – zárolási technikára – 1.

X=20, Y=10Ütemezés: T1, T2 Eredmény:X=15, Y=25

Ütemezés: T2, T1 Eredmény:X= 5, Y=3025Database Systems - Tranzakciók

(gyakorlat)

T1 T2

lock-x(x) lock-s(y)

read(x) read(y)

X:=X-Y/2 unlock(y)

write(x) lock-x(y)

unlock(x) read(y)

lock-s(y) Y:=Y+X

read(y) write(y)

unlock(y) unlock(y)

Példa – zárolási technikára – 2.


T1 T2

read(B)

B := B-50

write(B)

read(A)

read(B)

read(A)

A := A+50

write(A)

Határozd meg a lockokat a következő ütemezésben: T1 T2

lock-X(B)

read(B)

B := B 50

write(B)

unlock(B)

lock-S(A)

read(A)

unlock(A)

lock-S(B)

read(B)

unlock(B)

lock-X(A)

read(A)

A := A + 50

write(A)

unlock(A)

Kétfázisú zárolási protokoll


Növekvő (growing) fázis: ebben a fázisban kell minden lock-ot kiadnia a

tranzakciónak

Csökkenő (shrinking) fázis: a zárolások feloldhatók, de új zárolás már

semmiképp sem adható ki ebben a fázisban


Kétfázisú zárolási protokoll

T1 T2

lock-s(Y) lock-s(X)read(Y) read(X)

lock-x(X) lock-x(Y)lock-x(Z)

unlock(Y) unlock(X)read(X) read(Y)X:=X+Y Y:=X+Y

Z:=X-Ywrite(X) write(Y)

write(Z)unlock(X) unlock(Y)

unlock(Z)

Growing Phase:

Shrinking Phase:

MJ: Tranzakciónként külön kell megállapítani a két fázist!

Growing Phase

Shrinking Phase

Database Systems - Tranzakciók (gyakorlat)

Add locks, unlocks, denote the two phase!

29

Tétel: A kétfázisú protokoll szerint futó tranzakciók

tetszőleges ütemezése sorbarendezhető.


Kétfázisú zárolási protokoll tétele

Lefut-e az alábbi összefésült kétfázisú ütemezés?

Mi lesz a végeredmény A=100, B=20 esetén?

Jelöld be a fázisokat!

Megoldás: Dead-Lock a

lock-x(B)—lock-s(A)—lock-s(B)—lock-x(A) miatt.

T1 T2lock-X(B) lock-S(A)

read(B) read(A)lock-X(A) lock-S(B)

read(A) read(B)B := B 50 unlock(A)write(B) unlock(B)

unlock(B)

A := A + 50

write(A)

unlock(A)


Példa 1. – Kétfázisú zárolási protokoll

Growing Phase:

Shrinking Phase:

T1 T2

lock-X(A)

read(A)

lock-S(B)

read(B)

lock-S(B)

read(B)

unlock(B)

A := A + B - 50

write(A)

unlock(A)


Példa 2. – Kétfázisú zárolási protokoll

Lefut-e az alábbi összefésült kétfázisú ütemezés?

Mi lesz a végeredmény A=100, B=20 esetén?

Jelöld be a fázisokat!

Megoldás: Igen, lefut. A végeredmény:

A=70, B=20 lesz.

Growing Phase:

Shrinking Phase:

09-05-11Database Systems - Tranzakciók (gyakorlat) 33



Példa: bankautomata, tranzakciószám, stb…

Minden tranzakció kap egy időbélyeget:

TS(Ti): i a tranzakció fiatalságát jelenti

kisebb TS ~ öregebb! (vö. szül. évszám…)

Minden adat is kap egy írási és egy olvasási

időbélyeget:

read-timestamp: RTS(X) – X az adat

write-timestamp: WTS(X) – X az adat lényegében legutóbb/legfiatalabbként kiolvasó/beíró

tranzakció TS-je

mindig a fiatalabb van előnyben, ha az öregebb akar olvasni,

az elavult

Időbélyegzési technika, TimeStamping

Szabályok – Időbélyegzési technika

1. Legyen Tj tranzakció, mely read(X) műveletet szeretnea)Ha TS(Tj) < W-timestamp(X), akkor Tj X-nek olyan értékét

olvasná ki, amit már fölülírtak azóta, így ezt a read-et elutasítjuk (+Tj rollback)

b)Ha TS(Tj) ≥ W-timestamp(X), akkor megtörténik az olvasás, és a R-timestamp(X) értékét az R-timestamp(X) és a TS(Tj) közül a legnagyobb értékére állítjuk max{r-timestamp(x),TS(Ti)}

2. Legyen Tj tranzakció olyan, mely write(X) műveletet hajtana végre

c)Ha TS(Tj) < W-timestamp(X), akkor Tj egy elavult adatot írna, így ezt a write-ot elutasítjuk (+Tj rollback)

d)Ha TS(Tj) < R-timestamp(X), akkor Tj olyanra állítaná be X-et, amit azóta már kiolvastak, így ezt a write-ot elutasítjuk (+Tj rollback)

e)Egyébként az írás végrehajtódik, és W-timestamp(X) értékét TS(Tj)-re állítjuk


Szabályok – Időbélyegzési technika1. Legyen Tj tranzakció, mely read(X) műveletet szeretne

a) Ha TS(Tj) < W-timestamp(X), akkor Tj X-nek olyan értékét olvasná ki, amit már fölülírtak azóta, így ezt a read-et elutasítjuk (+Tj rollback)

b) Ha TS(Tj) ≥ W-timestamp(X), akkor megtörténik az olvasás, és a R-timestamp(X) értékét az R-timestamp(X) és a TS(Tj) közül a legnagyobb értékére állítjuk max{r-timestamp(x),TS(Ti)}

2. Legyen Tj tranzakció olyan, mely write(X) műveletet hajtana végre

c) Ha TS(Tj) < W-timestamp(X), akkor Tj egy elavult adatot írna, így ezt a write-ot elutasítjuk (+Tj rollback)

d) Ha TS(Tj) < R-timestamp(X), akkor Tj olyanra állítaná be X-et, amit azóta már kiolvastak, így ezt a write-ot elutasítjuk (+Tj rollback)

e) Egyébként az írás végrehajtódik, és W-timestamp(X) értékét TS(Tj)-re állítjuk

Thomas’ Writing Rule: 2. a) ~vakoníráskor: Tj-ben write(X) igény =>

ha RTS(X) < TS(Tj) < WTS(X), akkor a write(X) művelet nem futhat le, de a tranzakció folytatódhat, mégsincs abort és rollback.


Példa 1.

write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1


Példa 1. – 1. lépés

write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1

RTS(X)=nullWTS(X)=nullTS(T2)=2

1. b) szabály

RTS(X)=2



write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1RTS(Z)=nullWTS(Z)=nullTS(T3)=32. c) szabály

RTS(X)=2

WTS(Z)=3



write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1 RTS(X)=2WTS(X)=nullTS(T1)=11. b) szabály

WTS(Z)=3

TS(T1) ? RTS(X)1 < 2

RTS(X)=2

RTS(X)=2



write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1RTS(X)=2WTS(X)=nullTS(T4)=41. b) szabály

WTS(Z)=3

TS(T4) ? RTS(X)4 > 2

RTS(X)=4

RTS(X)=2

RTS(X)=2



write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1

RTS(X)=4WTS(X)=nullTS(T3)=31. b) szabály

WTS(Z)=3

TS(T3) ? RTS(X)3 < 4

RTS(X)=2

RTS(X)=4

RTS(X)=2

RTS(X)=4



write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1

RTS(Y)=nullWTS(Y)=nullTS(T2)=22. c) szabály

WTS(Z)=3

RTS(X)=2

WTS(Y)=2

RTS(X)=2

RTS(X)=4

RTS(X)=4



write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1

RTS(Y)=nullWTS(Y)=2

TS(T4)=4

1. b) szabály

WTS(Z)=3

RTS(X)=2

RTS(Y)=4

RTS(X)=2

RTS(X)=4

RTS(X)=4

WTS(Y)=2

1. read-kérdés:TS(T4) ? WTS(Y)

4 > 2



write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1

RTS(Z)=null

WTS(Z)=3TS(T2)=2

1. a) szabály

WTS(Z)=3

RTS(X)=2

T2 abortál+ rollback:WTS(Y):=n

ull

RTS(X)=2

RTS(X)=4

RTS(X)=4

WTS(Y)=2

RTS(Y)=4

1. read-kérdés:TS(T2) ? WTS(Z)

2 < 3



write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1

RTS(X)=4WTS(X)=nu

llTS(T1)=1

2. b) szabály

WTS(Z)=3

RTS(X)=2

T1 abortál(+

rollback: nincs mit)

RTS(X)=2

RTS(X)=4

RTS(X)=4

WTS(Y)=2 2. write-kérdés:TS(T1) ? RTS(X)

1 < 4RTS(Y)=4



write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1

RTS(X)=4WTS(X)=nu

llTS(T5)=5

WTS(Z)=3

RTS(X)=2

RTS(X)=2

RTS(X)=4

RTS(X)=4

RTS(Y)=4

1. b) szabályTS(T5) ?

RTS(X)5 > 4

RTS(X)=5



write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1

RTS(Y)=4WTS(Y)= 2

nullTS(T3)=3

WTS(Z)=3

RTS(X)=2

RTS(X)=2

RTS(X)=4

RTS(X)=4

RTS(Y)=4

1. b) szabályTS(T3) ? RTS(Y)

3 < 4

RTS(Y)=4

RTS(X)=5

1. read-kérdés:TS(T3) ? WTS(Y)

3 > null


50


write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1

WTS(Z)=3

RTS(X)=2

RTS(X)=2

RTS(X)=4

RTS(X)=4

WTS(Y)=2

RTS(Y)=4

2.c) szabály

WTS(Y)=5

RTS(X)=5

2. write-kérdés:TS(T5) ? WTS(Y)

5 > nullTS(T5) ? RTS(Y)

5 > 4

RTS(Y)=4


RTS(Y)=4WTS(Y)= 2

nullTS(T5)=5

51


write(Y)13.

12.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Y)

read(Y)

read(X)

write(X)

read(Z)

read(Y)

write(Y)

read(X)

read(X)

read(X)

write(Z)

read(X)

T5T4T3T2T1

RTS(Y)=4WTS(Y)=5TS(T4)=4

WTS(Z)=3

RTS(X)=2

RTS(X)=2

RTS(X)=4

RTS(X)=4

WTS(Y)=2

RTS(Y)=4

2.b) szabály

RTS(X)=5


4 < 5

RTS(Y)=4WTS(Y)=5

T4 abortál+

rollback:RTS(Y):=3


RTS(Y)=3

Példa 1. – Thomas szabály?

Hogyan változna a lefutás, ha engedélyeznénk a Thomas írási szabályt?

A 13. lépésben write(Y)-igény van,RTS(Y)=4, WTS(Y)=5, TS(T4)=4

TS(T4)=4 < 5=WTS(Y) ütközik, de TS(T4)=4 = 4=RTS(Y) nem,

ezért a Thomas szabály értelmében nem fog lefutni ez a write(Y), viszont a T4 nem abortál, folytatódhat a tranzakció.


Példa 1. 13. – lépés Thomas szabállyal

T1 T2 T3 T4 T5

1. read(X)

2. write(Z)

3. read(X)

4. read(X)

5. read(X)

6. write(Y)

7. read(Y)

8. read(Z)

9. write(X)

10. read(X)

11. read(Y)

12. write(Y)

13. write(Y)

RTS(Y)=4WTS(Y)=5TS(T4)=4WTS(Z)=3

RTS(X)=2

RTS(X)=2

RTS(X)=4

RTS(X)=4

WTS(Y)=2

RTS(Y)=4

2.b) szabály

RTS(X)=5


4 < 5

RTS(Y)=4WTS(Y)=5

T4 abortálna+ rollback( )

Thomas’ Writing Rule:

RTS(Y) ≤ TS(T4) < WTS(Y)

4 ≤ 4 < 5write(Y) nem hajtódik végre,

DE T4 folytatódhat!…

Példa 1. – végeredmény

T3 és T5 tranzakció marad megX: read-ts(x)= 5

write-ts(x)= null (abort miatt)Y: read-ts(y)=3, Thomas’Rule-lal 4 marad.

write-ts(y)=5Z:read-ts(z)= null

write-ts(z)=3


Példa 2.

11.

10.

9.

8.

7.

6.

5.

4.

3.

2.

1.

write(Z)

write(Y)

write(Z)

read(X)

read(X)

read(Z)

write(Z)

write(Y)

read(Y)

read(Y)

read(X)

T5T4T3T2T1


Példa 2. – HF.

Mely tranzakciók abortálódnak?

Mik az adattagok időbélyegei?

Alkalmazható-e a Thomas writing rule?


Documents

Tranzakciók gyakorlati anyag