Concorrenza Java - Blocca interfaccia

Un'interfaccia java.util.concurrent.locks.Lock viene utilizzata come meccanismo di sincronizzazione dei thread simile ai blocchi sincronizzati. Il nuovo meccanismo di blocco è più flessibile e fornisce più opzioni rispetto a un blocco sincronizzato. Le principali differenze tra un blocco e un blocco sincronizzato sono le seguenti:

• Guarantee of sequence- Il blocco sincronizzato non fornisce alcuna garanzia di sequenza in cui verrà concesso l'accesso al thread in attesa. L'interfaccia di blocco lo gestisce.

• No timeout- Il blocco sincronizzato non ha alcuna opzione di timeout se il blocco non è concesso. L'interfaccia di blocco fornisce tale opzione.

• Single method - Il blocco sincronizzato deve essere contenuto completamente in un unico metodo, mentre i metodi lock () e unlock () di un'interfaccia di blocco possono essere chiamati con metodi differenti.

Metodi di blocco

Di seguito è riportato l'elenco dei metodi importanti disponibili nella classe Lock.

Sr.No.	Metodo e descrizione
1	public void lock() Acquisisce il blocco.
2	public void lockInterruptibly() Acquisisce il blocco a meno che il thread corrente non venga interrotto.
3	public Condition newCondition() Restituisce una nuova istanza di condizione associata a questa istanza di blocco.
4	public boolean tryLock() Acquisisce il blocco solo se è libero al momento dell'invocazione.
5	public boolean tryLock() Acquisisce il blocco solo se è libero al momento dell'invocazione.
6	public boolean tryLock(long time, TimeUnit unit) Acquisisce il blocco se è libero entro il tempo di attesa specificato e il thread corrente non è stato interrotto.
7	public void unlock() Rilascia il blocco.

Esempio

Il seguente programma TestThread mostra alcuni di questi metodi dell'interfaccia Lock. Qui abbiamo usato lock () per acquisire il lock e unlock () per rilasciare il lock.

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();
   }
}

Questo produrrà il seguente risultato.

Produzione

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.

Abbiamo usato la classe ReentrantLock come implementazione dell'interfaccia Lock qui. La classe ReentrantLock consente a un thread di bloccare un metodo anche se ha già il blocco su un altro metodo.