Sincronização com Locks

Locks É um mecanismo de sincronização de processos/threads em que estas devem ser programadas de modo que seus efeitos sobre os dados compartilhados sejam equivalentes serialmente.

Locks Um exemplo simples de mecanismos para disposição em série é o caso de locks (travas) exclusivos. Nesse esquema, um servidor tenta impedir o acesso (travar) a qualquer objeto que esteja para ser usado por qualquer operação de uma thread (ou transação) de um cliente do servidor.

Locks Se um cliente solicitar acesso a um objeto que já está bloqueado (travado) devido a uma thread de outro cliente, o pedido será suspenso e o cliente deverá esperar até que o objeto seja destravado.

Locks A implementação de locks pode ser feita para que o funcionamento dos locks (travas) para bloqueio, sejam implementados por um objeto em separado num servidor, que chamamos de gerenciador de locks (travas).

Locks O gerenciador de locks (travas) mantém um conjunto de locks (por exemplo, numa tabela hashing). Cada lock (trava) é uma instância da classe Lock e é associado a um objeto (uma conta bancária, por exemplo) em particular.

Locks Os métodos de Lock são sincronizados para que as threads (transações) que estão tentando adquirir (método aquire, que usa wait) ou liberar (método release, que usa notify) uma trava, não interfiram umas com as outras.

Locks Tentativas de adquirir a trava usam o método wait quando precisam esperar que outra thread a libere. Todos os pedidos para obter travas (locks) e liberá-las em nomes de threads (transações) são enviadas para uma instância do gerenciador de travas (class LockManager).

Instructors Guide for Coulouris, Dollimore, Kindberg and Blair, Distributed Systems: Concepts and Design Edn. 5 © Pearson Education 2012 Figure LockManager class public class LockManager { private Hashtable theLocks; public void setLock(Object object, TransID trans, LockType lockType){ Lock foundLock; synchronized(this){ // find the lock associated with object // if there isnt one, create it and add to the hashtable } foundLock.acquire(trans, lockType); } // synchronize this one because we want to remove all entries public synchronized void unLock(TransID trans) { Enumeration e = theLocks.elements(); while(e.hasMoreElements()){ Lock aLock = (Lock)(e.nextElement()); if(/* trans is a holder of this lock*/ ) aLock.release(trans); }

Instructors Guide for Coulouris, Dollimore, Kindberg and Blair, Distributed Systems: Concepts and Design Edn. 5 © Pearson Education 2012 Figure Lock class public class Lock { private Object object;// the object being protected by the lock private Vector holders; // the TIDs of current holders private LockType lockType; // the current type public synchronized void acquire(TransID trans, LockType aLockType ){ while(/*another transaction holds the lock in conflicing mode*/) { try { wait(); }catch ( InterruptedException e){/*...*/ } } if(holders.isEmpty()) { // no TIDs hold lock holders.addElement(trans); lockType = aLockType; } else if(/*another transaction holds the lock, share it*/ ) ){ if(/* this transaction not a holder*/) holders.addElement(trans); } else if (/* this transaction is a holder but needs a more exclusive lock*/) lockType.promote(); } Continues on next slide

Instructors Guide for Coulouris, Dollimore, Kindberg and Blair, Distributed Systems: Concepts and Design Edn. 5 © Pearson Education 2012 Figure Lock class continued public synchronized void release(TransID trans ){ holders.removeElement(trans); // remove this holder // set locktype to none notifyAll(); }