access-policies:
  - resource: /api/users/**
    methods: [GET, POST]
    required-roles: [USER, ADMIN]
    required-permissions: [users:read]
    conditions:
      - time: "09:00-17:00"
      - day-of-week: [MON-FRI]
  
  - resource: /api/admin/**
    methods: [*]
    required-roles: [ADMIN]
    ip-whitelist: [192.168.1.0/24]

import java.util.*;

public class Task191225 {
    public static void main(String[] args) {
        Deque<String> deque1 = new LinkedList<>();
        Deque<String> deque2 = new ArrayDeque<>();
        
        System.out.println(deque1.getFirst());
        System.out.println(deque2.getFirst());
    }
}

// Визуализация объекта в памяти (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

public interface Comparable<T> {
    int compareTo(T o);
}

// Рекомендуется (но не обязательно), чтобы:
x.compareTo(y) == 0 ⇔ x.equals(y) == true
Нарушение этого принципа может привести к тонким ошибкам, особенно при использовании в коллекциях, основанных на упорядочивании (например, TreeSet, TreeMap).

BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("1.00");

System.out.println(bd1.equals(bd2));    // false (разный масштаб)
System.out.println(bd1.compareTo(bd2)); // 0 (равны по значению)
Это историческое решение было принято для соответствия стандарту ANSI SQL, но оно служит предостережением о сложностях реализации сравнения.

public int compareTo(Employee other) {
    int result = this.lastName.compareTo(other.lastName);
    if (result != 0) return result;
    
    result = this.firstName.compareTo(other.firstName);
    if (result != 0) return result;
    
    return this.hireDate.compareTo(other.hireDate);
}
Такой подход создает иерархический порядок, где более значимые поля сравниваются первыми.

public int compareTo(Person other) {
    if (other == null) {
        throw new NullPointerException("Cannot compare with null");
    }
    // ... сравнение
}
Это решение основано на принципе "явное лучше неявного" — лучше получить немедленное исключение, чем молчаливую ошибку в логике упорядочивания.

// Упрощенная концепция реализации
public int compareTo(String anotherString) {
    int len1 = value.length;
    int len2 = anotherString.value.length;
    int lim = Math.min(len1, len2);
    
    for (int k = 0; k < lim; k++) {
        char c1 = value[k];
        char c2 = anotherString.value[k];
        if (c1 != c2) {
            return c1 - c2; // Сравнение символов
        }
    }
    return len1 - len2; // Более короткая строка "меньше"
}

public int compareTo(Integer anotherInteger) {
    return compare(this.value, anotherInteger.value);
}

public static int compare(int x, int y) {
    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
Обратите внимание на использование статического метода compare, который появился в Java 7 для улучшения читаемости.

LocalDate date1 = LocalDate.of(2023, 1, 1);
LocalDate date2 = LocalDate.of(2023, 12, 31);

int result = date1.compareTo(date2); // Отрицательное число

// ОПАСНО: возможное переполнение!
public int compareTo(MyInteger other) {
    return this.value - other.value;
}
При больших значениях разность может выйти за пределы int, что приведет к некорректным результатам.

public int compareTo(MyInteger other) {
    return Integer.compare(this.value, other.value);
}

// ОПАСНО: нарушение транзитивности из-за NaN!
public int compareTo(DoubleWrapper other) {
    return Double.compare(this.value, other.value);
    // Double.compare корректно обрабатывает NaN
}

Значения с плавающей точкой, особенно NaN, требуют особой осторожности при сравнении.

public int compareTo(Object other) {
    if (!(other instanceof MyClass)) {
        throw new ClassCastException("Cannot compare different types");
    }
    return compareTo((MyClass) other);
}

public class Employee implements Comparable<Employee> {
    private final String name;
    private final LocalDate hireDate;
    
    @Override
    public int compareTo(Employee other) {
        // Делегируем сравнение имени
        int nameComparison = this.name.compareTo(other.name);
        if (nameComparison != 0) {
            return nameComparison;
        }
        // При равных именах сравниваем даты найма
        return this.hireDate.compareTo(other.hireDate);
    }
}

Collections.sort(list, Collections.reverseOrder());
// Или для конкретного компаратора
Collections.sort(list, Comparator.reverseOrder());
Паттерн "Null-safe сравнение"
С Java 8 появились удобные методы для null-safe сравнения:

java
public int compareTo(Product other) {
    return Comparator.comparing(Product::getName, 
                                Comparator.nullsFirst(String::compareTo))
                     .thenComparing(Product::getPrice)
                     .compare(this, other);
}

public int compareTo(Person other) {
    // Вместо: return this.age - other.age;
    return Integer.compare(this.age, other.age);
}
Эти методы не только безопасны от переполнения, но и часто лучше оптимизируются JVM.

public final class ComplexNumber implements Comparable<ComplexNumber> {
    private final double real;
    private final double imaginary;
    private transient int hash; // Кэшированный хэш-код
    private transient Integer comparisonCache; // Кэш сравнения
    
    @Override
    public int compareTo(ComplexNumber other) {
        if (comparisonCache == null) {
            // Дорогое вычисление порядка
            comparisonCache = computeComparisonValue();
        }
        // Сравнение на основе кэшированного значения
        return comparisonCache.compareTo(other.getComparisonCache());
    }
}

import java.util.*;

public class Task201225 {
    public static void main(String[] args) {
        List<Number> list = new ArrayList<>();
        list.add(10);     // Integer
        list.add(5.5);    // Double
        list.add(3);      // Integer
        list.add(2.0);    // Double
        
        Collections.sort(list);
        
        System.out.println(list);
    }
}