Ο συγχρονισμός νημάτων έχει σαν στόχο να επιτρέπει σε διαφορετικά νήματα να διαβάζουν ή να γράφουν με ασφάλεια σε διαμοιραζόμενες μεταβλητές χωρίς να προκύπτουν ασάφειες ως προς τις τιμές των μεταβλητών αυτών λόγω ταυτόχρονης μεταβολής τους. Ο προσεκτικός αναγνώστης θα παρατηρήσει ότι την προστασία των διαμοιραζόμενων μεταβλητών μπορούμε να την διασφαλίσουμε με την χρήση συγχρονισμένων μπλοκ ή συγχρονισμένων μεθόδων. Το παραπάνω είναι σωστό, με την προϋπόθεση ότι τα νήματα επιθυμούμε να εκτελούνται παράλληλα. Εάν τα νήματα δεν πρέπει να εκτελεστούν παράλληλα, αλλά το ένα νήμα θα πρέπει να περιμένει το άλλο να ολοκληρώσει τότε τα συγχρονισμένα block από μόνα τους δεν αποτελούν λύση. Σε αυτή την περίπτωση απαιτείται η έννοια της κλειδαριάς (lock).

Ας υποθέσουμε ότι έχουμε δύο νήματα Α, Β και το νήμα Α θέλει να ειδοποιήσει το νήμα Β μόλις ολοκληρώσει την επεξεργασία των δεδομένων του, ώστε εκείνο να ξεκινήσει την επεξεργασία των δεδομένων που δημιουργήθηκαν. Δεν μας αρκεί δηλαδή τα νήματα Α, Β να εκτελούνται παράλληλα, αλλά θα θέλαμε το νήμα Β να ξεκινήσει την επεξεργασία μόλις το νήμα Α ολοκληρώσει.

Ο πιο απλός τρόπος για να επικοινωνήσουν δύο νήματα μεταξύ τους είναι μέσω διαμοιραζόμενων αντικειμένων. Για το παραπάνω παράδειγμα, ας υποθέσουμε ότι το νήμα Α θέτει την boolean τιμή locked σε true μέσα από μία συγχρονισμένη μέθοδο και το νήμα Β διαβάζει την τιμή locked και πάλι μέσω μίας συγχρονισμένης μεθόδου

MyLock.java

public class MyLock{
 
  protected boolean locked = false;
 
  public synchronized boolean isLocked(){
    return locked;
  }
 
  public synchronized void lock (){
    locked = true;  
  }
 
  public synchronized void unlock (){
    locked = false;  
  }
}

Η παραπάνω κλάση μπορεί να χρησιμοποιηθεί για την επικοινωνία μεταξύ δύο νημάτων Α, Β. Ας υποθέσουμε ότι το νήμα Β περιμένει έως ότου τα δεδομένα να είναι διαθέσιμα από το νήμα Α, περιμένοντας διαρκώς σε ένα while() βρόγχο, όπως παρακάτω:

BusyWait.java

import java.util.*;
 
public class BusyWait implements Runnable {
 
  protected MyLock lock;
 
  BusyWait(MyLock l) {
    lock = l;
  }
 
  public static void main(String args[]) {
    MyLock sharedLock = new MyLock();
    new Thread(new BusyWait(sharedLock)).start();
    new Thread(new BusyWait(sharedLock)).start();
  }
 
  public void run() {
    try {
      while(lock.isLocked() == true) {
        Thread.sleep(300);
        System.out.println(Thread.currentThread().getName()+" awaites locked for the lock.");
      }
      // Uncomment the following line and see threads running concurrently.
      // Thread.sleep(10);
      lock.lock();   
      for(int i=0; i<10; i++) {
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+" iteration: "+i);
      }
      lock.unlock();
      System.out.println("Exiting!");
    }
    catch(InterruptedException ex) {
      ex.printStackTrace();
    }
  }
}

Στο παράδειγμα αυτό το νήμα περιμένει, αλλά παράλληλα παραμένει και ενεργό (busy). Επίσης, θα παρατηρήσετε ότι με σημαντική πιθανότητα (αλλά όχι βεβαιότητα) τα δύο νήματα θα εκκινήσουν ταυτόχρονα και ταυτόχρονα διαβάσουν την τιμή lock.isLocked() → true και θα αρχίσουν να εκτελούνται παράλληλα πράγμα που δεν το θέλουμε. Δοκιμάστε να μεταγλωττίσετε και να εκτελέσετε μερικές φορές για να διαπιστώσετε την ταυτόχρονη εκτέλεση των νημάτων.

Το παραπάνω σχήμα δεν είναι αποτελεσματικό ως προς τον συγχρονισμό και επίσης δαπανά πολλά resources καθώς το νήμα Β παραμένει ενεργό περιμένοντας. Θα ήταν πιο αποδοτικό αν αντί να παραμένει ενεργό το νήμα Β “κοιμόταν” περιμένοντας το νήμα Α να ολοκληρώσει. Η Java διαθέτει ένα μηχανισμό προκειμένου να επιτρέψει σε νήματα να κοιμηθούν περιμένοντας τα νήματα που εκτελούνται να ολοκληρώσουν το έργο τους. Συγκεκριμένα διαθέτει τρεις μεθόδους που επιτρέπουν το συγκεκριμένο συγχρονισμό wait(), notify(), notifyAll().

Όταν ένα νήμα καλεί την μέθοδο wait() πάνω σε ένα αντικείμενο, τότε το νήμα κοιμάται έως ότου ένα άλλο νήμα καλέσει τη μέθοδο notify() πάνω στο ίδιο αντικείμενο. Τότε το νήμα που κοιμόταν ξυπνάει και συνεχίζει την εκτέλεση του. Το νήμα που καλεί τις wait() και notify() θα πρέπει να έχει λάβει προηγουμένως το monitor lock για το συγκεκριμένο αντικείμενο, δηλαδή τόσο η wait() όσο και η notify() θα πρέπει να κληθούν μέσα σε μία συγχρονισμένη μέθοδο ή συγχρονισμένο μπλοκ. Δείτε το παρακάτω παράδειγμα συγχρονισμού με χρήση των wait()/notify().

MyWaitNotify.java

public class MyWaitNotify{
 
  Object myMonitorObject = new Object();
  boolean wasSignalled = true;
 
  public void doWait(){
    synchronized(myMonitorObject){
      if(!wasSignalled){
        try{
          myMonitorObject.wait();
         } catch(InterruptedException e){...}
      }
      //clear signal and continue running.
      wasSignalled = false;
    }
  }
 
  public void doNotify(){
    synchronized(myMonitorObject){
      wasSignalled = true;
      myMonitorObject.notify();
    }
  }
}

Η μέθοδος notify() ξυπνάει ένα νήμα που περιμένει στο συγκεκριμένο monitor lock. Όπως βλέπετε οι μέθοδοι wait() και notify() καλούνται μέσα σε ένα συγχρονισμένο block του οποίου το monitor lock αφορά το αντικείμενο από το οποίο καλούνται οι wait() και notify(). Το παραπάνω σχήμα είναι υποχρεωτικό, δηλαδή (ισχύουν και τα δύο παρακάτω):

1. οι wait() και notify() θα πρέπει να κληθούν μέσα σε ένα συγχρονισμένο block ή μία συγχρονισμένη μέθοδο.
2. Κατά την κλήση των wait()/notify() μπορούμε να καλέσουμε τις wait()/notify() μόνο για το αντικείμενο του οποίου έχουμε αποκτήσει το monitor lock. Εάν δεν ισχύει αυτό τότε λαμβάνουμε ένα IllegalMonitorStateException.

Εκτός από τη μέθοδο notify() που ξυπνάει ένα νήμα από όσα περιμένουν υπάρχει και η notifyAll() που ξυπνάει όλα τα νήματα που περιμένουν για το συγκεκριμένο monitor lock. Όταν περισσότερα του ενός νήματα περιμένουν, το ποιο νήμα από όλα θα ξυπνήσει η μέθοδος notify() δεν ελέγχεται από εσάς. Είστε όμως βέβαιοι ότι θα ξυπνήσει ένα νήμα.

Ας δούμε τώρα πως υλοποιείται ο παραπάνω μηχανισμός συγχρονισμού. Όταν ένα νήμα περιμένει μέσω της wait() ελευθερώνει παράλληλα το monitor lock που έχει λάβει για το αντικείμενο myMonitorObject, Η απελευθέρωση του monitor lock επιτρέπει σε άλλα νήματα που δεν έχουν το lock να το λάβουν μπαίνοντας σε ένα συγχρονισμένο block ή συγχρονισμένη μέθοδο.

Υπάρχει η πιθανότητα ένα νήμα να ξυπνήσει ακόμη και δίχως να κληθεί η notify() ή η notifyAll(), εφόσον το monitor lock είναι ελεύθερο. Αν και οι περιπτώσεις αυτές δεν είναι συχνές δεν θα πρέπει να αποκλειστούν. Σε αυτή την περίπτωση αν το νήμα λάβει το lock θα ξυπνήσει και θα συνεχίσει την εκτέλεση του δίχως να εξετάσει αν έχει έρθει ένα σήμα ή όχι. Για το λόγο αυτό, καλό θα είναι ο έλεγχος που γίνεται παραπάνω (μέσα στην if()) να αντικατασταθεί με ένα while() loop ώστε να είμαστε σίγουροι ότι όσο δεν έχει αλλάξει η τιμή της μεταβλητής wasSignalled το νήμα που περιμένει δεν θα συνεχίσει την εκτέλεση του. Δείτε τον τελικό κώδικα παρακάτω

MyWaitNotify2.java

public class MyWaitNotify2{
 
  Object myMonitorObject = new Object();
  boolean wasSignalled = false;
 
  public void doWait(){
    synchronized(myMonitorObject){
      while(!wasSignalled){
        try{
          myMonitorObject.wait();
         } catch(InterruptedException e){...}
      }
      //clear signal and continue running.
      wasSignalled = false;
    }
  }
 
  public void doNotify(){
    synchronized(myMonitorObject){
      wasSignalled = true;
      myMonitorObject.notify();
    }
  }
}

Παρατηρήστε ότι η κλάση MyWaitNotify2 υλοποιεί ένα μία απλή κλειδαριά, όπου μόνο ένα νήμα μπορεί να πάρει την κλειδαριά, ενώ όλα τα υπόλοιπα νήματα περιμένουν. Μόλις ολοκληρώσει την επεξεργασία ελευθερώνει την κλειδαριά και ενημερώνει ένα από τα νήματα που περιμένουν να ξεκινήσει. Η παραπάνω κλάση θα μπορούσε να γραφεί με την μορφή κλειδαριάς ως εξής:

SimpleLock.java

public class SimpleLock {
 
  Object myMonitorObject = new Object();
  boolean wasSignalled = false;
 
  public void lock(){
    synchronized(myMonitorObject){
      while(!wasSignalled){
        try{
          myMonitorObject.wait();
         } catch(InterruptedException e){...}
      }
      //clear signal and continue running.
      wasSignalled = false;
    }
  }
 
  public void unlock(){
    synchronized(myMonitorObject){
      wasSignalled = true;
      myMonitorObject.notify();
    }
  }
}