import lombok.Synchronized;

public class Counter {
    private int count = 0;

    @Synchronized
    public void increment() {
        count++;
    }

    @Synchronized("lock")
    public void decrement() {
        count--;
    }

    private final Object lock = new Object();
}

public class Counter {
    private int count = 0;
    private final Object $lock = new Object(); // Скрытое поле для синхронизации
    private final Object lock = new Object();

    public void increment() {
        synchronized ($lock) {
            count++;
        }
    }

    public void decrement() {
        synchronized (lock) {
            count--;
        }
    }
}

// Визуализация объекта в памяти (64-bit, compressed oops):
Object obj = new Object();
// Адрес в памяти: 0x000000076ab0c410
// Содержимое:
// [0x0000000000000001]  ← Mark Word (8 байт)
// [0x00000007c0060c00]  ← Указатель на класс (4/8 байт)
// [данные объекта...]    ← Поля вашего класса

// Примерный вид записи в Mark Word:
// 1. НЕБЛОКИРОВАННЫЙ (01) — "свободен для аренды"
// Пример: 0x0000000000000001
//                 ↑↑ последние биты = 01

// 2. ЛЁГКАЯ БЛОКИРОВКА (00) — "занято, но ключ простой"
// Пример: 0x000070000d65f468
//                 ↑↑ последние биты = 00

// 3. ТЯЖЁЛАЯ БЛОКИРОВКА (10) — "занято, очередь у двери"
// Пример: 0x00007f8c8400d1a2
//                 ↑↑ последние биты = 10

State selectLockingStrategy(Object obj, Thread thread) {

    // Проверяем, не помечен ли объект для GC
    if (isMarkedForGC(obj)) return State.GC_MARKED;
    
    // Проверяем, есть ли сохранённый хэш
    if (hasIdentityHash(obj)) return State.HASH_STORED;
    
    // Смотрим историю использования объекта
    LockingProfile profile = getProfile(obj);
    
    if (profile.isSingleThreaded()) {

        // Один поток → тонкая блокировка
        return attemptThinLock(obj, thread);

    } else if (profile.hasWaiters()) {

        // Есть wait() → тяжёлая блокировка
        return inflateToHeavyLock(obj);

    } else if (profile.isHighlyContended()) {

        // Много конкурентов → тяжёлая с оптимизациями
        return createAdaptiveLock(obj);

    }
    
    // Дефолт: начинаем с тонкой
    return attemptThinLock(obj, thread);
}

// Простейший случай — один поток синхронизируется на объекте
Object lock = new Object();

// До синхронизации:
// Mark Word = 0x0000000000000001 (неблокированный)

synchronized(lock) {
    // 1. JVM проверяет последние биты: 01
    // 2. Пытается сделать CAS (сравнить-и-заменить):
    //    Было: 0x0000000000000001
    //    Стало: 0x000070000d65f468
    //                 ↑ указатель на стек потока | 00
    // 3. Успех! Поток вошёл в блок
    
    counter++; // Критическая секция
}

// После выхода:
// Mark Word снова = 0x0000000000000001
// (лёгкая блокировка снимается)

Что важно: В этом сценарии не создаётся Monitor! Всё работает через быструю CAS-операцию.

// Два потока хотят один объект
Object sharedLock = new Object();

Thread t1 = new Thread(() -> {
    synchronized(sharedLock) {
        Thread.sleep(100); // Держит блокировку
    }
});

Thread t2 = new Thread(() -> {
    // Пытается войти, пока t1 внутри
    synchronized(sharedLock) {
        // Здесь произойдёт инфляция — переход от легковесной блокировки (состоящей лишь из флагов в Mark Word)
        // к использованию полноценного объекта-монитора, способного управлять очередями.
    }
});

t1.start();
t2.start();

T2 видит: Mark Word = [...][00] (лёгкая блокировка от T1)

T2 ждёт немного ("спин"), пробует снова — не получается

JVM создаёт Monitor — полноценный объект-диспетчер

Mark Word меняется на: [указатель на Monitor][10]

T2 встаёт в очередь Monitor'а

УНИВЕРСАЛЬНАЯ КОНЦЕПЦИЯ (работает везде):
[Объект] → [Монитор] → {
    - Владелец (owner)
    - Счетчик рекурсий (recursions)
    - Очередь для synchronized (entry queue)
    - Очередь для wait() (wait set)
}

import org.openjdk.jol.info.ClassLayout;

public class LockDemo {
    public static void main(String[] args) throws Exception {
        Object obj = new Object();
        
        System.out.println("=== 1. НОВЫЙ ОБЪЕКТ ===");
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
        // Mark Word: 0x0000000000000001 (неблокированный)
        
        synchronized(obj) {
            System.out.println("\n=== 2. В SYNCHRONIZED (1 поток) ===");
            System.out.println(ClassLayout.parseInstance(obj).toPrintable());
            // Mark Word: 0x000070000d65f468 (лёгкая блокировка)
        }
        
        // Создаём конкуренцию
        Thread t1 = new Thread(() -> {
            synchronized(obj) {
                try { Thread.sleep(500); } catch (Exception e) {}
            }
        });
        
        t1.start();
        Thread.sleep(100); // Даём t1 захватить блокировку
        
        synchronized(obj) {
            System.out.println("\n=== 3. ПРИ КОНКУРЕНЦИИ ===");
            System.out.println(ClassLayout.parseInstance(obj).toPrintable());
            // Mark Word: 0x00007f8c8400d1a2 (тяжёлая блокировка)
        }
    }
}

=== 1. НОВЫЙ ОБЪЕКТ ===
java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable)
  8   4        (object header: class)    0xf80001e5

=== 2. В SYNCHRONIZED (1 поток) ===
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000070000d65f468 (thin lock: ...)
  8   4        (object header: class)    0xf80001e5

=== 3. ПРИ КОНКУРЕНЦИИ ===
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x00007f8c8400d1a2 (inflated)
  8   4        (object header: class)    0xf80001e5