Simultaneidade Java - interface de bloqueio

Uma interface java.util.concurrent.locks.Lock é usada como mecanismo de sincronização de thread semelhante aos blocos sincronizados. O novo mecanismo de travamento é mais flexível e oferece mais opções do que um bloco sincronizado. As principais diferenças entre um bloqueio e um bloco sincronizado são as seguintes -

  • Guarantee of sequence- O bloco sincronizado não oferece nenhuma garantia de sequência na qual o thread em espera terá acesso. A interface de bloqueio cuida disso.

  • No timeout- O bloco sincronizado não tem opção de tempo limite se o bloqueio não for concedido. A interface de bloqueio fornece essa opção.

  • Single method - O bloco sincronizado deve estar totalmente contido em um único método, enquanto os métodos lock () e unlock () de uma interface de bloqueio podem ser chamados em métodos diferentes.

Métodos de bloqueio

A seguir está a lista de métodos importantes disponíveis na classe Lock.

Sr. Não. Método e Descrição
1

public void lock()

Adquire a fechadura.
2

public void lockInterruptibly()

Adquire o bloqueio, a menos que o segmento atual seja interrompido.
3

public Condition newCondition()

Retorna uma nova instância de Condition que está vinculada a esta instância de Lock.
4

public boolean tryLock()

Adquire o bloqueio apenas se estiver livre no momento da invocação.
5

public boolean tryLock()

Adquire o bloqueio apenas se estiver livre no momento da invocação.
6

public boolean tryLock(long time, TimeUnit unit)

Adquire o bloqueio se ele estiver livre dentro do tempo de espera determinado e o segmento atual não tiver sido interrompido.
7

public void unlock()

Libera o bloqueio.

Exemplo

O programa TestThread a seguir demonstra alguns desses métodos da interface Lock. Aqui, usamos lock () para obter o bloqueio e desbloquear () para liberar o bloqueio.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class PrintDemo {
   private final Lock queueLock = new ReentrantLock();

   public void print() {
      queueLock.lock();

      try {
         Long duration = (long) (Math.random() * 10000);
         System.out.println(Thread.currentThread().getName() 
            + "  Time Taken " + (duration / 1000) + " seconds.");
         Thread.sleep(duration);
      } catch (InterruptedException e) {
         e.printStackTrace();
      } finally {
         System.out.printf(
            "%s printed the document successfully.\n", Thread.currentThread().getName());
         queueLock.unlock();
      }
   }
}

class ThreadDemo extends Thread {
   PrintDemo  printDemo;

   ThreadDemo(String name,  PrintDemo printDemo) {
      super(name);
      this.printDemo = printDemo;
   }   

   @Override
   public void run() {
      System.out.printf(
         "%s starts printing a document\n", Thread.currentThread().getName());
      printDemo.print();
   }
}

public class TestThread {

   public static void main(String args[]) {
      PrintDemo PD = new PrintDemo();

      ThreadDemo t1 = new ThreadDemo("Thread - 1 ", PD);
      ThreadDemo t2 = new ThreadDemo("Thread - 2 ", PD);
      ThreadDemo t3 = new ThreadDemo("Thread - 3 ", PD);
      ThreadDemo t4 = new ThreadDemo("Thread - 4 ", PD);

      t1.start();
      t2.start();
      t3.start();
      t4.start();
   }
}

Isso produzirá o seguinte resultado.

Resultado

Thread - 1  starts printing a document
Thread - 4  starts printing a document
Thread - 3  starts printing a document
Thread - 2  starts printing a document
Thread - 1   Time Taken 4 seconds.
Thread - 1  printed the document successfully.
Thread - 4   Time Taken 3 seconds.
Thread - 4  printed the document successfully.
Thread - 3   Time Taken 5 seconds.
Thread - 3  printed the document successfully.
Thread - 2   Time Taken 4 seconds.
Thread - 2  printed the document successfully.

Usamos a classe ReentrantLock como uma implementação da interface Lock aqui. A classe ReentrantLock permite que um thread bloqueie um método, mesmo se já tiver o bloqueio em outro método.