Antwoord.

Achtergrond van de vraag:

Sinds de opkomst van Java zijn ontwikkelaars geconfronteerd met het probleem van gelijktijdige toegang tot gedeelde bronnen. Om dit op te lossen zijn er high-level synchronisatieprimitieven geïntroduceerd, waarvan de belangrijkste de sleutelmodificeerder synchronized is.

Probleem:

Zonder synchronisatie in multi-threaded applicaties kunnen gedeelde bronnen beschadigd raken: er ontstaat een data race en de staat van het object wordt onvoorspelbaar.

Oplossing:

synchronized maakt het mogelijk om een monitor te organiseren voor een methode of codeblok, waardoor slechts één thread tegelijkertijd toegang heeft tot de kritieke sectie. Thread-synchronisatie kan worden geïmplementeerd op het niveau van een methode of blok.

Voorbeeld van het vergrendelen van een object:

public class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public int getCount() {
        return count;
    }
}

Blokken kunnen ook worden gesynchroniseerd:

public void safeIncrement() {
    synchronized(this) {
        count++;
    }
}

Belangrijke kenmerken:

Synchronisatie op methodeniveau is gelijk aan synchronisatie op this-niveau
Voor statische methoden is synchronisatie op klassenniveau
Het is noodzakelijk om de kritieke sectie te minimaliseren

Lastige vragen.

Wat is het verschil tussen een synchronized-methode en een synchronized-blok?

Een synchronized-methode blokkeert de gehele methode voor het huidige object (this) of de klasse (als de methode statisch is). Een blok maakt het mogelijk om alleen het benodigde stuk code te synchroniseren en om een willekeurig object voor vergrendeling te kiezen.

Kunnen twee verschillende threads tegelijkertijd binnenkomen in twee verschillende synchronized-methoden van één object?

Nee, als de methoden zijn gesynchroniseerd op dezelfde monitor (this). Als verschillende monitoren worden gebruikt, dan ja.

Beïnvloedt de modifier synchronized de zichtbaarheid van variabelen tussen threads?

Ja, de toegang tot een synchronized-blok reset de caches van de threads en werkt de waarden van de variabelen bij (happens-before relatie).

Typische fouten en anti-patterns

Synchronisatie op een te "breed" object (bijvoorbeeld, op String of klass-object)
Lange uitvoering van code binnen een gesynchroniseerd blok
Mixen van toegang tot één bron via synchronized-blokken en niet-synchroniseerde secties

Voorbeeld uit het leven

Negatieve case

Een ontwikkelaar synchroniseert statische methoden van de klasse op een instantie-object, wat geen correctheid garandeert bij gebruik via verschillende instanties.

Voordelen:

Eenvoudige implementatie

Nadelen:

Onverwachte data races tussen threads
Moeilijk te traceren bugs

Positieve case

Alle methoden die gebruikmaken van een gedeelde bron worden gesynchroniseerd op één object-monitor, de kritieke sectie is minimaal.