Η Java παρέχει δύο βασικούς τρόπους συγχρονισμού προκειμένου να αποφεύγονται τα προβλήματα συγχρονισμού που παρουσιάστηκαν προηγούμενα α) τις συγχρονισμένες μεθόδους και β) τα συγχρονισμένα blocks.

Η διαδικασίες συγχρονισμού που περιγράφονται παρακάτω βασίζονται σε έναν εσωτερικό μηχανισμό που διαθέτουν όλα τα αντικείμενα στην Java, το λεγόμενο intrinsic lock ή monitor lock ή monitor.

Όταν ένα νήμα θέλει να εκτελέσει τη συγχρονισμένη μέθοδο ενός αντικειμένου θα πρέπει να λάβει το monitor lock για το αντικείμενο αυτό. Αντίστοιχα, όταν το ίδιο νήμα θα βγει από την συγχρονισμένη μέθοδο του αντικειμένου θα ελευθερώσει το monitor lock για το αντικείμενο. Όταν ένα νήμα έχει το monitor lock για ένα αντικείμενο, κανένα άλλο νήμα δεν μπορεί να λάβει ταυτόχρονα αυτό το lock. Μόνο το υφιστάμενο αντικείμενο μπορεί να αφήσει το lock εξερχόμενο από την συγχρονισμένη μέθοδο ή το συγχρονισμένο block.

Προκειμένου να δημιουργήσετε μία συγχρονισμένη μέθοδο σε μία κλάση αρκεί να προσθέσετε το keyword synchronized κατά την δήλωση της μεθόδου, όπως παρακάτω

SynchronizedCounter.java

public class SynchronizedCounter {
  private int c = 0;
 
  public synchronized void increment() {
    c++;
  }
 
  public synchronized void decrement() {
    c--;
  }
 
  public synchronized int value() {
    return c;
  }
}

Αν έχουμε ένα αντικείμενο counter της παραπάνω κλάσης τότε ισχύουν τα παρακάτω

• Δεν είναι δυνατόν η ίδια συγχρονισμένη μέθοδος ή διαφορετικές συγχρονισμένες μέθοδοι ενός αντικειμένου να κληθούν ταυτόχρονα από διαφορετικά νήματα. Ας υποθέσουμε ότι ένα νήμα εκτελεί μία από τις συγχρονισμένες μεθόδους ενός αντικειμένου. Όσα άλλα νήματα επιχειρούν να έχουν πρόσβαση σε συγχρονισμένες μεθόδους του ιδίου αντικειμένου, αναμένουν έως ότου το τρέχον νήμα να ολοκληρώσει την εκτέλεση της συγχρονισμένης μεθόδου την οποία εκτελεί και να ελευθερώσει το monitor lock για το αντικείμενο αυτό. Αυτό διασφαλίζει ότι η αλληλουχία των κλήσεων του παραδείγματος των νημάτων A,B που παρουσιάστηκε σε προηγούμενη σελίδα θα είναι η ενδεδειγμένη.

Σε αναλογία με τις συγχρονισμένες μεθόδους ορίζονται και τα συγχρονισμένα blocks με την διαφορά ότι τα συγχρονισμένα blocks οφείλουν να ορίσουν το αντικείμενο του οποίου λαμβάνουν το monitor lock, όπως παρακάτω

public class SynchronizedCounter {
  private int c = 0; 
  public void increment() { synchronized (this) {c++;} } 
  public void decrement() { synchronized (this) {c--;} } 
  public int value() { synchronized (this) {return c;} }
}

Στο παρακάτω παράδειγμα έχουμε δύο συγχρονισμένα blocκ μέσα σε δύο μη συγχρονισμένες μεθόδους. Η διαφορά είναι ότι η κλάση ορίζει δύο επιπλέον αντικείμενα μόνο και μόνο για να χρησιμοποιήσει τα monitor locks των αντικειμένων αυτών

SyncBlock.java

public class SyncBlock {
    private long c1 = 0;
    private long c2 = 0;
    private Object lock1 = new Object();
    private Object lock2 = new Object();
 
    public void inc1() {
        synchronized(lock1) {
            while(true) {
               for(long i=0; i<999999999L; i++)
                 ;
               System.out.println("Counter1: "+ ++c1);
            }
        }
    }
 
    public void inc2() {
        synchronized(lock2) {
            while(true) {
               for(long i=0; i<999999999L; i++)
                 ;
               System.out.println("Counter2: "+ ++c2);
            }
        }
    }
}

SyncBlockThread.java

public class SyncBlockThread extends Thread {
  SyncBlock block;
  boolean counter1;
  public SyncBlockThread(SyncBlock block, boolean counter1) {
    this.block = block;
    this.counter1 = counter1;
  }
 
  public void run() {
    if(counter1)
      block.inc1();
    else
      block.inc2();
  }
 
  public static void main(String []args) {
    SyncBlock block = new SyncBlock();
    new SyncBlockThread(block, true).start();
    new SyncBlockThread(block, false).start();
  }
}

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

NestedSyncMethods.java

public class NestedSyncMethods {
  void synchronized outer() {
    inner();
  }
 
  void synchronized inner() {
   ...
  }
}