Semester Ganjil 2014 Fak. Teknik Jurusan Teknik Informatika Universitas Pasundan. Caca E. Supriana, S.Si.,MT.

(1)

Semester Ganjil 2014

Fak. Teknik Jurusan Teknik Informatika

Universitas Pasundan

Caca E. Supriana, S.Si.,MT.

(2)

Two‐Phase Locking Techniques

y Locking adalah sebuah operasi yang mengamankan (a) izin untuk Baca (Read) atau (b) izin untuk Tulis (Write) item data untuk transaksi Contoh: Lock (X) (Write) item data untuk transaksi. Contoh: Lock (X). Item data X terkunci dalam nama transaksi yang meminta. y Unlocking adalah sebuah operasi yang menghilangkan hak akses ini dari item data. Contoh: Unlock (X). Item data X dibuat tersedia untuk semua transaksi lainnya.

y Lock dan Unlock adalah operasi Atomik

(3)

y Dua mode kunci (a) shared (read) dan (b) eksklusif (write).

M d Sh d b b i l k (X) L bih d i

y Mode Shared: berbagi lock (X). Lebih dari satu transaksi dapat menerapkan berbagi kunci pada X untuk membaca nilainya tetapi tidak ada menulis untuk membaca nilainya tetapi tidak ada menulis kunci dapat diterapkan pada X oleh transaksi lainnya. y Mode Eksklusif: Menulis lock (X). Hanya satu y menulis kunci pada X dapat ada pada setiap waktu dan tidak ada kunci bersama dapat diterapkan oleh transaksi lain pada X transaksi lain pada X.

(4)

y Lock Manager: Mengelola kunci pada item data.

y Lock Table: Kunci manajer menggunakannya untuk

i id ifik i k i i

menyimpan mengidentifikasi transaksi mengunci item data, data barang, modus kunci dan pointer ke item data berikutnya terkunci Salah satu cara item data berikutnya terkunci. Salah satu cara sederhana untuk menerapkan tabel kunci adalah melalui linked list. T1

Transaction ID Data item id lock mode Ptr to next data item Next

(5)

Database membutuhkan semua transaksi harus dibentuk dengan baik. Sebuah transaksi yang baik akan terbentuk jika: akan terbentuk jika: y Transaksi harus mengunci item data sebelum membaca atau menulis membaca atau menulis. y Transaksi tidak harus mengunci item data yang sudah terkunci dan tidak harus mencoba untuk membuka item data yang bebas (unlocked).

(6)

Lock operation

B: if LOCK (X) = 0 (*item is unlocked*)

h OC ( ) (*l k h i *)

then LOCK (X) ← 1 (*lock the item*) else begin

wait (until lock (X) 0) and wait (until lock (X) = 0) and

the lock manager wakes up the transaction);

goto B goto B end;

(7)

Unlock operation

LOCK (X) ← 0 (*unlock the item*)

if i i i h

if any transactions are waiting then

(8)

Read operation

B: if LOCK (X) = “unlocked” then begin LOCK (X) ← “read‐locked”;

f d (X)

no_of_reads (X) ← 1; end

else if LOCK (X) ← “read‐locked” then( )

no_of_reads (X) ← no_of_reads (X) +1

else begin wait (until LOCK (X) = “unlocked” and

h l k k h i )

go to B end;

(9)

Write lock operation

B: if LOCK (X) = “unlocked” then

begin LOCK (X) ← “write‐locked”; no of reads (X) ← 1;

no_of_reads (X) ← 1; end

else if LOCK (X) ← “write‐locked” then

no_of_reads (X) ← no_of_reads (X) +1

else begin wait (until LOCK (X) = “unlocked” and

th l k k th t ti )

go to B end;;

(10)

Unlock operation

if LOCK (X) = “write‐locked” then if LOCK (X) write locked then begin LOCK (X) ← “unlocked”;

wakes up one of the transactions, if any

d end

else if LOCK (X) ← “read‐locked” then beging no_of_reads (X) ← no_of_reads (X) ‐1 if no_of_reads (X) = 0 then b i begin LOCK (X) = “unlocked”;

wake up one of the transactions, if anyp f f y

end end;

(11)

Lock conversion

Lock upgrade: existing read lock to write lock

if Ti has a read‐lock (X) and Tj has no read‐lock (X) (i ≠ j) then

t d l k (X) t it l k (X)

convert read‐lock (X) to write‐lock (X) else

force Ti to wait until Tj unlocks X

Lock downgrade: existing write lock to read lock

Ti has a write‐lock (X) (*no transaction can have any lock on X*)

t it l k (X) t d l k (X)

(12)

Algorithm

y Dua Tahap: (a) Locking (growing) (b) Unlocking (shrinking). y Tahap Locking (growing) : Sebuah transaksi berlaku y Tahap Locking (growing) : Sebuah transaksi berlaku kunci (membaca atau menulis) pada item data yang diinginkan satu per satu. y Tahap Unlocking (shrinking): Sebuah transaksi membuka item datanya dikunci satu per satu. y Persyaratan: Untuk transaksi kedua fase harus saling y Persyaratan: Untuk transaksi kedua fase harus saling eksklusif, yaitu selama fase mengunci membuka fase tidak harus mulai dan selama unlocking fase fase i tid k h di l i penguncian tidak harus dimulai.

(13)

(14)

Algoritma untuk Two‐Phase Locking Techniques

Algoritma untuk Two Phase Locking Techniques

T1 T2 Result

read lock (Y); read lock (X); Initial values: Y=30; X=20 read_lock (Y); read_lock (X); Initial values: Y=30; X=20

read_item (Y); read_item (X); Result of serial execution

unlock (Y); unlock (X); T1 followed by T2

write_lock (X); Write_lock (Y); X=50, Y=80.5

read_item (X); read_item (Y); Result of serial execution

X:=X+Y; Y:=X+Y; T2 followed by T1

write_item (X); write_item (Y); X=70, Y=50

(15)

T1 T2 Result read_lock (Y); X=50; Y=50 read_item (Y); Nonserializable because it. unlock (Y); violated two‐phase policy. read lock (X); read_lock (X); read_item (X); unlock (X); write_lock (Y); d ( ) Time read_item (Y); Y:=X+Y; write_item (Y); unlock (Y); unlock (Y); write_lock (X); read_item (X); X:=X+Y;

(16)

T’1 T’2

read_lock (Y); read_lock (X); T1 and T2 follow two‐phase

read item (Y); read item (X); policy but they are subject to

read_item (Y); read_item (X); policy but they are subject to

write_lock (X); Write_lock (Y); deadlock, which must be

unlock (Y); unlock (X); dealt with.

read_item (X); read_item (Y);

X X Y Y X Y

X:=X+Y; Y:=X+Y;

write_item (X); write_item (Y);

(17)

y Kebijakan dua tahap menghasilkan dua algoritma penguncian (a) Dasar dan (b) Konservatif. y Konservatif: Mencegah kebuntuan dengan mengunci Konservatif: Mencegah kebuntuan dengan mengunci semua item data yang diinginkan sebelum transaksi dimulai eksekusi. y Dasar: Transaksi mengunci item data secara bertahap Hal y Dasar: Transaksi mengunci item data secara bertahap. Hal ini dapat menyebabkan kebuntuan yang harus ditangani. y Ketat (Strict): Sebuah versi yang lebih ketat dari algoritma

d di l ki dil k k l h k i

dasar di mana unlocking dilakukan setelah transaksi

berakhir (melakukan atau dibatalkan dan roll‐back). Ini adalah yang paling umum digunakan pada algoritma

(18)

Deadlock & Starvation

Deadlock T’1 T’2 d l k ( ) d d d f ll h read_lock (Y); T1 and T2 did follow two‐phase read_item (Y); policy but they are deadlock read_lock (X); read item (Y); read_item (Y); write_lock (X); (waits for X) write_lock (Y); (waits for Y) Deadlock (T’1 and T’2)

(19)

Starvation

y Starvation terjadi ketika transaksi tertentu secara konsisten menunggu atau restart dan tidak pernah mendapat kesempatan untuk melangkah lebih jauh. mendapat kesempatan untuk melangkah lebih jauh. Dalam resolusi kebuntuan adalah mungkin bahwa transaksi yang sama dapat secara konsisten terpilih sebagai korban dan roll back sebagai korban dan roll‐back. y Keterbatasan ini melekat dalam semua mekanisme penjadwalan berbasis prioritas. Dalam skema Wound‐ p j p Wait transaksi yang lebih muda mungkin selalu dibatalkan dengan transaksi lebih tua yang telah lama berjalan yang dapat menciptakan starvation. berjalan yang dapat menciptakan starvation.

(20)

Timestamp

y Sebuah variabel monoton yang meningkat (integer) yang menunjukkan usia operasi atau transaksi. Sebuah nilai timestamp yang lebih besar menunjukkan nilai timestamp yang lebih besar menunjukkan peristiwa atau operasi yang lebih baru.

y Algoritma berbasis Timestamp menggunakan Algoritma berbasis Timestamp menggunakan

timestamp untuk serialisasi pelaksanaan transaksi konkuren.

(21)

Timestamp based concurrency control algorithm

Basic Timestamp Ordering

Transaction T issues a write item(X) operation:

1. Transaction T issues a write_item(X) operation:

a. If read_TS(X) > TS(T) or if write_TS(X) > TS(T), then an younger transaction has already read the data item so abort and roll back T and reject the data item so abort and roll‐back T and reject the operation.

b. If the condition in part (a) does not exist, then execute write item(X) of T and set write TS(X) to execute write_item(X) of T and set write_TS(X) to TS(T).

2. Transaction T issues a read_item(X) operation: If i TS(X) TS(T) h

a. If write_TS(X) > TS(T), then an younger transaction has already written to the data item so abort and roll‐back T and reject the operation.

(22)

Strict Timestamp Ordering

1. Transaction T issues a write_item(X) operation:

a If TS(T) > read TS(X) then delay T until the

a. If TS(T) > read_TS(X), then delay T until the transaction T’ that wrote or read X has terminated (committed or aborted).

2 Transaction T issues a read item(X) operation: 2. Transaction T issues a read_item(X) operation:

a. If TS(T) > write_TS(X), then delay T until the transaction T’ that wrote or read X has terminated (committed or aborted)

(23)

Thomas’s Write Rule

1. If read_TS(X) > TS(T) then abort and roll‐back T and reject the operation.j p

2. If write_TS(X) > TS(T), then just ignore the write operation and continue execution. This is because the most recent writes counts in case of two consecutive writes.

3. If the conditions given in 1 and 2 above do not occur, then execute write_item(X) of T and set write_TS(X) to( ) ( ) TS(T).