Πώς συγχρονίζετε την πρόσβαση σε κοινή κατάσταση;

Question

Accepted Answer

**Συγχρονισμός** συντονίζει την πρόσβαση των threads σε κοινή μεταβαλλόμενη κατάσταση ώστε οι λειτουργίες να μην εμπλέκονται επικίνδυνα, αποτρέποντας **race conditions**. Η Java προσφέρει πολλούς μηχανισμούς, από την ενσωματωμένη λέξη-κλειδί `synchronized` έως σε ρητές κλειδαριές και lock-free ατομικές λειτουργίες.

## synchronized — αμοιβαία αποκλεισμός (intrinsic locks)

```java
class BankAccount {
    private double balance;

// synchronized method — acquires the object's lock; only ONE thread at a time
    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;   // protected — no interleaving
        }
    }
    // synchronized block — finer-grained, lock on a specific object
    public void deposit(double amount) {
        synchronized (this) {
            balance += amount;
        }
    }
}
```

Το `synchronized` διασφαλίζει ότι μόνο ένα thread εκτελεί τον προστατευμένο κώδικα κάθε φορά (αμοιβαία αποκλεισμός) και παρέχει **visibility** — οι αλλαγές ενός thread γίνονται ορατές στα άλλα (διασχίζει το memory barrier).

## volatile — visibility χωρίς atomicity

```java
private volatile boolean running = true;   // guarantees VISIBILITY across threads

public void stop() { running = false; }     // other threads see the change immediately
public void run() { while (running) { ... } } // without volatile, might never see false
```

Το `volatile` εγγυάται ότι οι ανάγνωσης/εγγραφές μιας μεταβλητής είναι ορατές μεταξύ threads — αλλά **ΔΕΝ** κάνει σύνθετες λειτουργίες (όπως `count++`) ατομικές. Χρησιμοποιήστε το για απλές σημαίες, όχι για read-modify-write.

## Atomic classes — lock-free atomicity

```java
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();        // atomic ++ without locking (uses CPU CAS instructions)
counter.compareAndSet(5, 10);     // atomic conditional update
```

Τα Atomic classes παρέχουν thread-safe λειτουργίες χωρίς κλειδαριές — συχνά ταχύτερες από το `synchronized` για απλούς μετρητές/συσσωρευτές.

## Explicit Locks — περισσότερος έλεγχος

```java
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // critical section
} finally {
    lock.unlock();   // ALWAYS unlock in finally
}
// ReadWriteLock allows many concurrent readers but exclusive writers
```

Το `ReentrantLock` προσφέρει χαρακτηριστικά που λείπουν από το `synchronized`: `tryLock()` (non-blocking), χρονικά περιορισμένες αναμονές, δικαιοσύνη και διαχωρισμό ανάγνωσης-εγγραφής.

## Οι κίνδυνοι που πρέπει να διαχειρίζεστε

```text
⚠️ Deadlock — two threads each hold a lock the other needs → both stuck forever
   (avoid by always acquiring locks in a consistent order)
⚠️ Performance — over-synchronizing serializes everything, killing concurrency
   (synchronize the SMALLEST necessary section)
⚠️ Forgetting to unlock (with explicit Locks) → use try/finally
```

## Γιατί είναι σημαντικό

Ο συγχρονισμός είναι απαραίτητος για ορθότητα όποτε πολλαπλά threads έχουν πρόσβαση σε κοινή μεταβαλλόμενη κατάσταση — χωρίς αυτόν, race conditions παράγουν κατεστραμμένα δεδομένα και διακοπτόμενες, σχεδόν αδύνατες να αποσφαλματωθούν αποτυχίες.

Η γνώση των εργαλείων και των ακριβών τους εγγυήσεων είναι κρίσιμη: `synchronized` (αμοιβαία αποκλεισμός + visibility), `volatile` (visibility μόνο — ΌΧΙ atomicity, μια κοινή παρανόηση), atomic classes (lock-free για απλές λειτουργίες), και ρητές Locks (προηγμένος έλεγχος).

Εξίσου σημαντικό είναι να κατανοείτε τους κινδύνους — **deadlock** και υπερβολικό συγχρονισμό που βλάπτει την απόδοση — και την πειθαρχία να συγχρονίζετε ελάχιστα και συνεπώς.

Αυτή είναι βασική, υψηλής απόδοσης γνώση για concurrent server-side Java και ένα βαθύ θέμα συνέντευξης που διακρίνει τους developers που μπορούν να γράψουν σωστό multithreaded κώδικα.