Το πακέτο java.util.concurrent παρέχει κάποια έτοιμα εργαλεία συγχρονισμού μεταξύ νημάτων στην java. Τα βασικά εργαλεία είναι τα εξής:

• BlockingQueue
• Semaphore
• Lock
• ReadWriteLock
• Atomic Integer, Long, Boolean, Reference

Ένα blocking queue είναι μία ουρά μηνυμάτων (queue) στην οποία μπορούν να γράφουν ή να διαβάζουν από αυτή με ασφάλεια δύο ή περισσότερα νήματα. Όταν η ουρά είναι άδεια και ένα νήμα επιχειρήσει να διαβάσει αυτό μπλοκάρει μέχρι κάποιο άλλο νήμα να γράψει στην ουρά. Αντίστοιχα, όταν ένα νήμα επιχειρεί να γράψει σε μία γεμάτη ουρά το νήμα μπλοκάρει μέχρι να ελευθερωθεί μία θέση στην ουρά μηνυμάτων από κάποιο άλλο νήμα που διάβασε. Στο παρακάτω σχήμα βλέπετε την σχηματική αναπαράσταση ενός blocking queue.

Οι βασικές μέθοδοι που υποστηρίζονται από ένα blocking queue είναι οι εξής:

Όλες οι παραπάνω μέθοδοι εξασφαλίζουν ότι μόνο ένα νήμα θα προσπελάσει τα κρίσιμα τμήματα κώδικα της δομή blocking queue (thread-safe), χωρίς όμως να μπορούν να προδιαγράψουν τη σειρά εκτέλεσης των νημάτων.

Υλοποιήσεις του interface Blocking Queue:

• ArrayBlockingQueue: Ένα blocking queue που υλοποιείται μέσω ενός πίνακα. Έχει πεπερασμένη χωρητικότητα.
• DelayQueue: Ένα blocking queue το οποίο αποθηκεύει τα στοιχεία και επιτρέπει την ανάκτηση των στοιχείων που αποθηκεύτηκαν μετά από συγκεκριμένη χρονική καθυστέρηση από την ώρα αποθήκευσης τους.
• LinkedBlockingQueue: Ένα blocking queue που υλοποιείται μέσω διπλά συνδεδεμένης λίστας. Μπορεί να έχει σταθερή ή μεταβαλλόμενη μέγιστη χωρητικότητα.
• PriorityBlockingQueue: Αποθηκεύει στοιχεία που υλοποιούν το interface java.lang.Comparable. Τα στοιχεία ανακτόνται με σειρά προτεραιότητας (με βάση την ταξινόμηση που υφίστανται). Αποτελεί συγχρονισμένη υλοποίηση της κλάσης java.util.PriorityQueue.
• SynchronousQueue: Πρόκειται για ένα blocking queue με χωρητικότητα μηδέν. Για να ενθέσουμε ένα στοιχείο στο queue από ένα νήμα θα πρέπει να υπάρχει ταυτόχρονα άλλο νήμα που θα λάβει το στοιχείο από το queue.

Στο πακέτο java.util.concurrent υλοποιείται η κλάση του σηματοφορέα έτοιμη προς χρήση. Οι βασικές μέθοδοι για τον σηματοφορέα είναι:

• Δέσμευση πόρων (acquire permits):
  • acquire(): Δέσμευει ένα permit, εφόσον αυτό είναι διαθέσιμο, διαφορετικά το νήμα μπλοκάρει. Εάν κατά την αναμονή το νήμα διακοπεί από άλλο νήμα τότε η μέθοδος “πετάει” InterruptedException.
  • acquire(int N): Δέσμευει Ν permits εφόσον είναι διαθέσιμα, διαφορετικά μπλοκάρει. Εάν κατά την αναμονή το νήμα διακοπεί από άλλο νήμα τότε η μέθοδος “πετάει” InterruptedException.
  • https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Semaphore.html#acquireUninterruptibly()|acquireUninterruptibly()]]: Δέσμευει ένα permit, εφόσον αυτό είναι διαθέσιμο, διαφορετικά το νήμα μπλοκάρει. Εάν κατά την αναμονή το νήμα διακοπεί από άλλο νήμα τότε αυτό εξακολουθεί και περιμένει.
  • acquireUninterruptibly(int permits): Δέσμευει Ν permits εφόσον είναι διαθέσιμα, διαφορετικά μπλοκάρει. Εάν κατά την αναμονή το νήμα διακοπεί από άλλο νήμα τότε αυτό εξακολουθεί και περιμένει.
  • tryAcquire(): Επιχειρεί να δεσμεύσει ένα permit, εφόσον αυτό είναι διαθέσιμο. Επιστρέφει true/false σε περίπτωση επιτυχίας/αποτυχίας.
  • tryAcquire(int N): Επιχειρεί να δεσμεύσει N permits, εφόσον αυτό είναι διαθέσιμα. Επιστρέφει true/false σε περίπτωση επιτυχίας/αποτυχίας.
  • tryAcquire(int permits, long timeout, TimeUnit unit): Δέσμευει ένα permit, εφόσον αυτό είναι διαθέσιμο, διαφορετικά το νήμα μπλοκάρει για χρονικό διάστημα ίσο με timeout. Επιστρέφει true εφόσον τα ζητούμενα permits είναι διαθέσιμα και false έαν το χρονικό όριο timeout παρέλθει χωρίς τα ζητούμενα permits να γίνουν διαθέσιμα. Εάν κατά την αναμονή το νήμα διακοπεί από άλλο νήμα τότε η μέθοδος “πετάει” InterruptedException.
  • drainPermits(): Λαμβάνει όλα τα διαθέσιμα permits. Επιστρέφει τον αριθμό τους.
• Απελευθέρωση πόρων (release permits):
  • release(): Απελευθερώνει ένα πόρο από τον σηματοφορέα. Δεν υπάρχει καμία προϋπόθεση το νήμα που απελευθερώνει ένα πόρο να τον έχει καταλάβει μέσω της acquire προηγούμενα.
  • release(int Ν): Απελευθερώνει Ν πόρους από τον σηματοφορέα. Δεν υπάρχει καμία προϋπόθεση το νήμα που απελευθερώνει τους πόρους να τους έχει καταλάβει μέσω της acquire προηγούμενα.

Νήματα που αναμένουν ένα ή περισσότερους πόρους του σηματοφορέα και μπορούν να ικανοποιηθούν από την απελευθέρωση πόρων ξυπνούν και χρονοπρογραμματίζεται η εκτέλεση τους.

Άλλες χρήσιμες μέθοδοι είναι:

• availablePermits: Επιστρέφει τον αριθμό των διαθέσιμων πόρων του σηματοφορέα.
• getQueuedThreads: Επιστρέφει τη λίστα με τα νήματα που περιμένουν να καταλάβουν πόρους του σηματοφορέα.
• getQueuedLength: Επιστρέφει τον αριθμό των νημάτων που περιμένουν να καταλάβουν πόρους του σηματοφορέα.

To interface java.util.concurrent.locks.Lock προδιαγράφει μία κλειδαριά, η οποία επιτρέπει μόνο σε ένα νήμα κάθε φορά να την κλειδώσει. Όλα τα νήματα που δεν καταφέρνουν να κλειδώσουν παραμένουν ανενεργά μέχρι η κλειδαριά να ξεκλειδώσει. Οι βασικές μέθοδοι που προδιαγράφει το συγκεκριμένο interface είναι οι εξής:

• lock(): Επιχειρεί να κλειδώσει την κλειδαριά. Εάν η κλειδαριά είναι κλειδωμένη αναμένει το ξεκλείδωμα της.
• tryLock(): Κλειδώνει την κλειδαριά μόνο εάν αυτή είναι ελεύθερη. Διαφορετικά επιστρέφει χωρίς να κλειδώσει.
• tryLock(long time, TimeUnit unit): Επιχειρεί να κλειδώσει τη κλειδαριά. Εάν η κλειδαριά είναι κλειδωμένη αναμένει για μέγιστο χρονικό διάστημα που περιγράφεται από τα ορίσματα της μεθόδου και εάν δεν γίνει διαθέσιμη επιστρέφει χωρίς να κλειδώσει.
• unlock(): Ξεκλειδώνει την κλειδαριά.

Υλοποίηση του παραπάνω interface είναι η κλάση java.util.concurrent.locks.ReentrantLock, η οποία επιτρέπει το πολλαπλό κλείδωμα της κλειδαριάς από το ίδιο νήμα. Το ξεκλείδωμα της κλειδαριάς πραγματοποιείται μόνον εφόσον το νήμα που κλείδωσε ξεκλειδώσει τόσες φορές όσες έχει προηγούμενα κλειδώσει. Η συγκεκριμένη κλάση δίνει την δυνατότητα του ισότιμου χρονοπρογραμματισμού των νημάτων που περιμένουν, εφόσον κληθεί ο κατασκευαστής με όρισμα true.

Το interface ReadWriteLock προδιαγράφει δύο κλειδαριές, μία για διάβασμα και μία για γράψιμο. Η διαφορά με την προηγούμενη κλειδαριά είναι ότι την κλειδαριά που επιτρέπει το διάβασμα μπορούν να την κλειδώσουν παράλληλα πολλά νήματα που θέλουν να διαβάσουν εάν δεν υπάρχει νήμα που θέλει να γράψει. Αντίστοιχα την κλειδαριά που επιτρέπει το γράψιμο μπορεί να την κλειδώσει μόνο ένα νήμα και παράλληλα απαγορεύεται η πρόσβαση στην κλειδαριά που επιτρέπει το διάβασμα. Συνοπτικά:

• ΜΟΝΟ ένα νήμα μπορεί να γράψει. Κανένα νήμα δεν μπορεί να διαβάσει.
• Πολλαπλά νήματα μπορούν να διαβάσουν εάν δεν υπάρχει νήμα που θέλει να γράψει.

Το παραπάνω interface υλοποιείται μεσω της κλάσης |java.util.concurrent.locks.ReentrantReadWriteLock. Η κλάση αυτή περιέχει δύο άλλες εσωτερικές κλάσεις την ReentrantReadWriteLock.ReadLock και ReentrantReadWriteLock.WriteLock. Η πρώτη χρησιμοποιείται για διάβασμα και η δεύτερη για γράψιμο.

Ας υποθέσουμε ότι έχετε το αρχείο κειμένου largedict.txt για το οποίο θέλετε να κάνετε τα εξής. Έχετε Ν νήματα που διαβάζουν από το αρχείο και Μ νήματα που στο νέο αρχείο. Θέλετε το νέο αρχείο που θα γραφεί να είναι ίδιο με το αρχικό αρχείο που διαβάστηκε. Το αρχείο κειμένου διαβάζεται και γράφεται γραμμή-γραμμή.

Για την επικοινωνία μεταξύ αναγνωστών και εγγραφέων θα χρησιμοποιηθεί ένα blocking queue με σχετικά περιορισμένη χωρητικότητα Κ, όπου K < min(M,N). Επίσης για την υλοποίηση του συγχρονισμού διαθέτουμε δύο κλειδαριές α) μία κλειδαριά η οποία βεβαιώνει ότι μόνο ένα νήμα διαβάζει από το αρχείο και γράφει στο Blocking Queue και β) μία κλειδαριά η οποία βεβαιώνει ότι μόνο ένα νήμα διαβάζει από το Blocking Queue και γράφει στο νέο αρχείο.

UtilConcurrentDemo1.java

import java.util.concurrent.*;
import java.util.concurrent.locks.*;
import java.io.*;
 
public class UtilConcurrentDemo1 {  
 
  public static void main(String args[]) {
    BufferedReader in;
    FileWriter out;
 
    if( args.length == 0 ) {
      System.err.println("Insufficient number of arguments!");
    }
    String filename = args[0];
 
    try {
      in = new BufferedReader(new FileReader(filename));
      out = new FileWriter(filename+".copy");
    }
    catch(IOException ex) {
      ex.printStackTrace();
      return ;
    }
 
    boolean useLocks = false;
 
    ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(2);
    ReentrantLock readLock = new ReentrantLock();
    ReentrantLock writeLock = new ReentrantLock();
    FileReaderQueueWriter w1 = new FileReaderQueueWriter(in, queue, writeLock, "QueueWriter-1", useLocks);
    FileReaderQueueWriter w2 = new FileReaderQueueWriter(in, queue, writeLock, "QueueWriter-2", useLocks);
    FileReaderQueueWriter w3 = new FileReaderQueueWriter(in, queue, writeLock, "QueueWriter-3", useLocks);
    FileWriterQueueReader r1 = new FileWriterQueueReader(out, queue, readLock, "QueueReader-1", useLocks);
    FileWriterQueueReader r2 = new FileWriterQueueReader(out, queue, readLock, "QueueReader-2", useLocks);
    FileWriterQueueReader r3 = new FileWriterQueueReader(out, queue, readLock, "QueueReader-3", useLocks);
    w1.start();
    w2.start();
    w3.start();
    r1.start();
    r2.start();
    r3.start();
  }
}
 
class FileReaderQueueWriter extends Thread {
  BufferedReader in;
  BlockingQueue<String> queue;
  ReentrantLock lock;
  boolean useLocks;
 
  public FileReaderQueueWriter(BufferedReader in, BlockingQueue<String> queue, ReentrantLock lock, String name, boolean useLocks) {
    this.in = in;
    this.queue = queue;
    this.lock = lock;
    setName(name);
    this.useLocks = useLocks;
  }
 
  void printError(String msg) {
    System.err.println("["+getName()+"] "+msg);
  }
 
  void printOut(String msg) {
    System.out.println("["+getName()+"] "+msg);
  }
 
  public void run() {
 
    int i=0; String input;
    try {
      while( true ) {
        if( useLocks )
          lock.lock();
        input = in.readLine();
        if( input != null) {
          queue.put(input);
 
          if( useLocks )
            lock.unlock();
        }
        else {
          if( useLocks )
            lock.unlock();
          break;
        }
      }
    }
    catch(IOException ex) {
      printError("IOException while reading!");
    }
    catch(InterruptedException ex) {
      printError("Queue put method interrupted.");
    }
    finally {
      if( useLocks && lock.isHeldByCurrentThread() )
        lock.unlock();
      try {
        in.close();
        printError("Buffered Reader closed!");
      } catch( IOException ex) {
        printError("IOException while closing! Stream already closed.");
      }
    }
  }
}
 
class FileWriterQueueReader extends Thread {
  FileWriter writer;
  BlockingQueue<String> queue;
  ReentrantLock lock;
  boolean useLocks;
 
  public FileWriterQueueReader(FileWriter writer, BlockingQueue<String>queue, ReentrantLock lock, String name, boolean useLocks) {
    this.writer = writer;
    this.queue = queue;
    this.lock = lock;
    setName(name);
    this.useLocks = useLocks;
  }
 
  void printError(String msg) {
    System.err.println("["+getName()+"] "+msg);
  }
 
  void printOut(String msg) {
    System.out.println("["+getName()+"] "+msg);
  }
 
  public void run() {
    try {
      String input;
      while( true) {
        if( useLocks )
          lock.lock();        
        if( (input = queue.poll(500, TimeUnit.MILLISECONDS)) != null ) {
          input += "\n";
          writer.append( input.subSequence(0, input.length()), 0, input.length() );
          if( useLocks )
            lock.unlock();
        }
        else {
          if( useLocks )
            lock.unlock();
          break;
        }
 
      }
    } catch(IOException ex) {
     printError("Error while writing to file!");
    } catch(InterruptedException ex) {
     printError("Tired of waiting. Queue is probably empty!");
    } finally {
      if( useLocks && lock.isHeldByCurrentThread() )
        lock.unlock();
      try {
        writer.close();
        printError("File Writer closed!");
      } catch( IOException ex) {
        printError("IOException while closing! Stream already closed.");
      }
    }
 
  }
}

Όπως ίσως θα γνωρίζετε η διασυνδεδεμένες λίστες που υπάρχουν στο πακέτο java.util δεν είναι συγχρονισμένες, δηλαδή δεν μπορούν να προσπελαστούν ταυτόχρονα από δύο ή περισσότερα νήματα. Προκειμένου να μπορούμε να προσπελάσουμε μία λίστα από περισσότερα του ενός νήματα δημιουργούμε την κλάση SynchronizedList η οποία χρησιμοποιεί ένα java.util.concurrent.locks.ReentrantLock.ReadLock για διάβασμα και ένα ReentrantReadWriteLock.WriteLock.html για μεταβολή του περιεχομένου της λίστας.

Δείτε πως διαμορφώνεται η κλάση καθώς και ένα παράδειγμα χρήσης της κλάσης αυτής.

UtilConcurrentDemo2.java

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;
 
class SynchronizedList<E> {
 
  ArrayList<E> list;
  ReentrantReadWriteLock lock;
  Lock rlock, wlock;
 
  public SynchronizedList() {
    list = new ArrayList<>();
    lock = new ReentrantReadWriteLock();
    rlock = lock.readLock();
    wlock = lock.writeLock();
  }
 
  public SynchronizedList(int capacity) {
    list = new ArrayList<>(capacity);
    lock = new ReentrantReadWriteLock();
    rlock = lock.readLock();
    wlock = lock.writeLock();
  }
 
  public void listWriteLock() {
    wlock.lock();
  }
 
  public void listWriteUnlock() {
    wlock.unlock();
  }
 
  public void listReadLock() {
    rlock.lock();
  }
 
  public void listReadUnlock() {
    rlock.unlock();
  }
 
  public void add(E e) {
    wlock.lock();
    list.add(e);
    wlock.unlock();
  }
 
  public void add(int index, E e) {
    wlock.lock();
    list.add(index, e);
    wlock.unlock();
  }
 
  public boolean addAll(Collection<? extends E> c) {
    wlock.lock();
    boolean result = list.addAll(c);
    wlock.unlock();
    return result;
  }
 
  public void clear() {
    wlock.lock();
    list.clear();
    wlock.unlock();
  }
 
  public boolean contains(Object o) {
    rlock.lock();
    boolean result = list.contains(o);
    rlock.unlock();
    return result;
  }
 
  public void ensureCapacity(int minCapacity) {
    wlock.lock();
    list.ensureCapacity(minCapacity);
    wlock.unlock();
  }
 
  public E get(int index) {
    rlock.lock();
    E e = list.get(index);
    rlock.unlock();
    return e;
  }
 
  public int indexOf(Object o) {
    rlock.lock();
    int index = list.indexOf(o);
    rlock.unlock();
    return index;
  }
 
  public boolean isEmpty() {
    rlock.lock();
    boolean empty = list.isEmpty();
    rlock.unlock();
    return empty;
  }
 
  public int lastIndexOf(Object o) {
    rlock.lock();
    int lastIndex = list.lastIndexOf(o);
    rlock.unlock();
    return lastIndex;
  }
 
  public E remove(int index) {
    wlock.lock();
    E e = list.remove(index);
    wlock.unlock();
    return e;
  }
 
  public E set(int index, E element) {
    wlock.lock();
    E e = list.set(index, element);
    wlock.unlock();
    return e;
  }
 
  public int size() {
    rlock.lock();
    int lsize = list.size();
    rlock.unlock();
    return lsize;
  }
 
  List<E> subList(int fromIndex, int toIndex) {
    rlock.lock();
    List<E> newlist = list.subList(fromIndex, toIndex);
    rlock.unlock();
    return newlist;
  }
 
  class SyncrhonizedIterator implements Iterator<E> {
    Iterator it;
    Lock rlock;
    Lock wlock;
 
    public SyncrhonizedIterator(Lock readlock, Lock writelock) {
      rlock = readlock;
      wlock = writelock;
      it = list.iterator();
    }
 
    public boolean hasNext() {
      rlock.lock();
      boolean hasnext = it.hasNext();
      rlock.unlock();
      return hasnext;
    }
 
    public E next() {
      rlock.lock();
      Object o = it.next();
      rlock.unlock();
      return (E)o;
    }
 
    public void remove() {
      wlock.lock();
      it.remove();
      wlock.unlock();
    }
  }
}
 
class ListModifierThread extends Thread {
  Random rand;
  SynchronizedList<Integer> list;
 
  public ListModifierThread(SynchronizedList<Integer> list) {
    this.list = list;
    rand = new Random( new Date().getTime() );
  }
 
  public void run() {
    for(int i=0; i<1000; i++)
      list.add( rand.nextInt(1000) );
 
    list.listWriteLock();    
    while( list.size() > 0 ) 
      System.out.println( list.remove( list.size()-1 ) );
 
    if( list.isEmpty() ) 
      System.out.println( this.getName() +": list is empty!");
    else
      System.out.println( this.getName() +": list is NOT empty!");    
    list.listWriteUnlock();
  }
}
 
class ListSynchronizer {
  public static void main(String []args) {
    SynchronizedList<Integer> list = new SynchronizedList<>();
 
    for(int i=0; i<10; i++) {
      (new ListModifierThread(list)).start();
    }
  }
}