Στον ταυτόχρονο προγραμματισμό, υπάρχουν δύο βασικές μονάδες εκτέλεσης: οι διεργασίες (processes) και τα νήματα (threads). Στη γλώσσα προγραμματισμού Java, ο ταυτόχρονος προγραμματισμός επιτυγχάνεται μέσω της χρήσης νημάτων.

Ένα υπολογιστικό σύστημα έχει συνήθως πολλές ενεργές διεργασίες και νήματα που εκτελούνται ταυτόχρονα. Αυτό ισχύει ακόμη και σε συστήματα που έχουν μόνο έναν πυρήνα στο υλικό τους, και ως εκ τούτου μπορούν να εκτελέσουν μόνο ένα νήμα ή διεργασία σε κάθε χρονική στιγμή. Ο χρόνος επεξεργασίας μεταξύ των διεργασιών μοιράζεται μέσω του χρονοπρογραμματιστή (scheduler) του λειτουργικού συστήματος.

Μία διεργασία έχει αυτόνομο περιβάλλον εκτέλεσης, δηλ έχει την δική της εικονική μνήμη και τις δικές της μεταβλητές. Συχνά οι διεργασίες ταυτίζονται με τα προγράμματα ή τις εφαρμογές, πράγμα που δεν είναι πάντα αληθές καθώς ένα πρόγραμμα μπορεί να είναι αποτέλεσμα περισσότερων διεργασιών οι οποίες επικοινωνούν μεταξύ τους μέσω κατάλληλων διεπαφών επικοινωνίας μεταξύ διεργασιών (Interprocess Communication - IPC), όπως ορίζει το κάθε λειτουργικό σύστημα.

Τα νήματα αναφέρονται συχνά και ως lightweight processes. Σε αναλογία με τις διεργασίες τα νήματα παρέχουν ένα περιβάλλον εκτέλεσης, αλλά απαιτούν λιγότερους πόρους κατά την δημιουργία τους σε σχέση με μία διεργασία. Τα νήματα ζουν μέσα στις διεργασίες (κάθε διεργασία έχει τουλάχιστον ένα νήμα) και μοιράζονται τους πόρους της διεργασίας, δηλαδή την μνήμη και τα αρχεία που έχει ανοίξει η διεργασία.

Η πολυνηματική εκτέλεση αποτελεί ένα από τα βασικά χαρακτηριστικά της πλατφόρμας Java. Κάθε Java εφαρμογή έχει ένα αρχικό νήμα εκτέλεσης, το οποίο εκκινεί μέσω της μεθόδου main. Το νήμα αυτό έχει τη δυνατότητα να δημιουργήσει πρόσθετα νήματα, μέσω της διαδικασίας που περιγράφεται παρακάτω.

Υπάρχουν δύο παρεμφερείς τρόποι για την δημιουργία και εκτέλεση νημάτων. Μία κλάση μπορεί να δημιουργήσει ένα νήμα είτε υλοποιώντας το interface java.lang.Runnable είτε επεκτείνοντας την κλάση java.lang.Thread (κλάση που υλοποιεί το παραπάνω interface). Και οι δύο τρόποι δημιουργίας και εκτέλεσης νημάτων παρατίθενται παρακάτω:

HelloRunnable.java

public class HelloRunnable implements Runnable {
  public void run() {
    System.out.println("Hello from a thread!");
  }
 
  public static void main(String args[]) {
    (new Thread(new HelloRunnable())).start();
  }
}

HelloThread.java

public class HelloThread extends Thread {
  public void run() {
    System.out.println("Hello from a thread!");
  }
 
  public static void main(String args[]) {
    (new HelloThread()).start();
  }
}

Παρατηρείστε ότι και τα δύο παραπάνω παραδείγματα καλούν την μέθοδο Thread.start(). Από τα δύο παραπάνω τρόπους ο πρώτος έχει το πλεονέκτημα ότι η νηματική κλάση δεν κληρονομεί την κλάση Thread (επομένως μπορεί να κληρονομήσει μία άλλη κλάση) και το μειονέκτημα ότι η νηματική κλάση δεν μπορεί να χρησιμοποιήσει καμία από τις μεθόδους που υλοποιεί η κλάση Thread (θα τις δούμε παρακάτω).

Η μέθοδος sleep δίνει την δυνατότητα σε ένα νήμα να σταματήσει την εκτέλεση του για ένα συγκεκριμένο χρονικό διάστημα. Κατά το διάστημα αυτό, άλλα νήματα της τρέχουσας διεργασίας μπορούν να εκτελεστούν. Θα πρέπει να έχουμε υπόψη μας ότι η χρονική διάρκεια κατά την οποία θα παύσει η εκτέλεση του νήματος μπορεί να έχει μικρές αποκλίσεις από τη χρονική διάρκεια που προσδιορίζεται στα ορίσματα της μεθόδου. Δείτε το παρακάτω παράδειγμα χρήσης της μεθόδου sleep.

SleepMessages.java

public class SleepMessages {
  public static void main(String args[])
    throws InterruptedException {
    String importantInfo[] = {
      "Peter Pan", 
      "leader of the Lost Boys", 
      "goes to Neverland"
    };
 
    for (int i=0; i<importantInfo.length; i++) {
      //Pause for 2 seconds
      Thread.sleep(2000);
      //Print a message
      System.out.println(importantInfo[i]);
    }
  }
}

Μία διακοπή (interrupt) αποτελεί ένδειξη προς την διεργασία να σταματήσει να κάνει αυτό που κάνει και να εκκινήσει κάτι διαφορετικό ή να τερματίσει. Η java υποστηρίζει την μέθοδο Thread.interrupt() για την αποστολή ενός σήματος διακοπής σε ένα νήμα. Εάν ένα νήμα έχει καλέσει τη μέθοδο sleep η κλήση της interrupt για το νήμα αυτό, θα το αφυπνίσει και θα παραχθεί ένα java.lang.InterruptedException για το νήμα που κοιμόταν. Για τον λόγο αυτό, η κλήση της sleep θα πρέπει να γίνεται πάντα μέσα σε ένα try/catch block της μορφής

  try {
    Thread.sleep(4000);
  } catch (InterruptedException e) {
    System.out.println("We've been interrupted: no more messages.");
    return;
  }

Εάν ένα νήμα δεν καλεί κάποια μέθοδο που δημιουργεί java.lang.InterruptedException και η εφαρμογή δουλεύει μέσω κλήσεων της μεθόδου interrupt, θα πρέπει περιοδικά να ελέγχει κατά πόσο υπάρχει κάποια σήμα διακοπής προς το συγκεκριμένο νήμα σε μία ανακύκλωση της μορφής

for (int i = 0; i < inputs.length; i++) {
    heavyCalc(inputs[i]);
    if (Thread.interrupted()) {
        throw new InterruptedException();
    }
}

Η μέθοδος join() επιτρέπει σε ένα νήμα να σταματήσει την εκτέλεση του έως ότου ένα άλλο νήμα να ολοκληρώσει την εκτέλεση του. Αν υποθέσουμε ότι ένα νήμα 't' εκτελείται παράλληλα με το τρέχον νήμα, εάν το τρέχον νήμα καλέσει το παρακάτω

  t.join();

τότε η εκτέλεση του σταματάει έως ότου το νήμα 't' να τερματίσει την εκτέλεση του. Υπάρχουν οι εξής παραλλαγές της μεθόδου join

• t.join(): περίμενε μέχρι το νήμα t να τερματίσει
• t.join(long millis): μέχρι το νήμα t να τερματίσει ή περίμενε για millis milliseconds.
• t.join(long millis, int nanos): μέχρι το νήμα t να τερματίσει ή περίμενε για millis+nanos/1000000 milliseconds.

Όπως και η μέθοδος sleep() η μέθοδος join() δύναται να διακοπεί μέσω της μεθόδου interrupt, παράγοντας ένα InterruptedException().

Δείτε το παρακάτω παράδειγμα εκτέλεσης δύο νημάτων, το οποίο χρησιμοποιεί τις μεθόδους sleep, interrupt και join. Το κεντρικό νήμα (μέθοδος main) περιμένει το νήμα που δημιουργείται για δεδομένο χρονικό διάστημα. Κάθε 1 δευτερόλεπτο το κεντρικό νήμα επιστρέφει από την μέθοδο join(1000) και εξετάζει εάν

1. ο χρόνος εκτέλεσης του ολοκληρώθηκε και
2. το παιδί δεν έχει ολοκληρώσει την εκτέλεση του. Ο έλεγχος γίνεται μέσω της μεθόδου isAlive.

Εάν ισχύουν και οι δύο παραπάνω προϋποθέσεις τότε στέλνει ένα interrupt στο παιδί και περιμένει έως ότου αυτό να τερματίσει μέσω της t.join(). Στην συνέχεια ολοκληρώνει και το κεντρικό νήμα την εκτέλεση του.

MessageLoops.java

public class MessageLoop implements Runnable {
  public void run() {
    String importantInfo[] = {
      "Mares eat oats",
      "Does eat oats",
      "Little lambs eat ivy",
      "A kid will eat ivy too"
    };
    try {
      for (int i = 0;
        i < importantInfo.length;
        i++) {
        // Pause for 4 seconds
        Thread.sleep(4000);
        // Print a message
        SimpleThreads.threadMessage(importantInfo[i]);
      }
    } catch (InterruptedException e) {
      SimpleThreads.threadMessage("I wasn't done!");
    }
  }
}

SimpleThreads.java

public class SimpleThreads {
 
  // Display a message, preceded by
  // the name of the current thread
  public static void threadMessage(String message) {
    String threadName =
      Thread.currentThread().getName();
    System.out.format("%s: %s%n",
              threadName,
              message);
  }  
 
  public static void main(String args[])
    throws InterruptedException {
 
    // Delay, in milliseconds before
    // we interrupt MessageLoop
    // thread (default one hour).
    long patience = 1000 * 60 * 60;
 
    // If command line argument
    // present, gives patience
    // in seconds.
    if (args.length > 0) {
      try {
        patience = Long.parseLong(args[0]) * 1000;
      } catch (NumberFormatException e) {
        System.err.println("Argument must be an integer.");
        System.exit(1);
      }
    }
 
    threadMessage("Starting MessageLoop thread");
    long startTime = System.currentTimeMillis();
    Thread t = new Thread(new MessageLoop());
    t.start();
 
    threadMessage("Waiting for MessageLoop thread to finish");
    // loop until MessageLoop
    // thread exits
    while (t.isAlive()) {
      threadMessage("Still waiting...");
      // Wait maximum of 1 second
      // for MessageLoop thread
      // to finish.
      t.join(1000);
      if (((System.currentTimeMillis() - startTime) > patience)
          && t.isAlive()) {
        threadMessage("Tired of waiting!");
        t.interrupt();
        // Shouldn't be long now
        // -- wait indefinitely
        t.join();
      }
    }
    threadMessage("Finally!");
  }
}