Зачем нужна синхронизация на типе класса?

Синхронизация на типе класса (Class-level Synchronization)

Синхронизация на типе класса — это механизм защиты статических полей и методов от одновременного доступа нескольких потоков. Это предотвращает race conditions при работе с общими данными на уровне класса.

Основные различия: Синхронизация объекта vs класса

Синхронизация объекта (объекта, например, this):

public class User {
    private int balance = 100;
    
    // Синхронизируем на объекте this
    public synchronized void transfer(int amount) {
        balance -= amount;  // Защищён этот объект
    }
}

User user1 = new User();
User user2 = new User();

// Разные объекты -> разные блокировки
// Поэтому оба потока могут выполняться параллельно

Синхронизация класса (статического состояния):

public class DatabaseConnection {
    private static int activeConnections = 0;
    
    // Синхронизируем на CLASS объекте
    public static synchronized void openConnection() {
        activeConnections++;  // Защищён весь класс
    }
}

// Все потоки конкурируют за одну блокировку класса
// Только один поток может быть в synchronized методе одновременно

Зачем нужна синхронизация класса

1. Защита статических полей

public class Logger {
    private static int requestCount = 0;
    
    public static synchronized void logRequest() {
        requestCount++;  // Без sync может быть потеря данных
    }
    
    public static synchronized int getCount() {
        return requestCount;
    }
}

// Без синхронизации:
// Thread1: читает 100, incrementing в памяти
// Thread2: читает 100, incrementing в памяти
// Оба пишут 101, вместо 102

2. Singleton Pattern — потокобезопасная реализация

public class DatabaseFactory {
    private static DatabaseFactory instance;
    
    // Синхронизация класса
    public static synchronized DatabaseFactory getInstance() {
        if (instance == null) {
            instance = new DatabaseFactory();
        }
        return instance;
    }
}

// Проблема: каждый вызов блокирует весь класс
// Решение: double-checked locking

Лучше с double-checked locking:

public class DatabaseFactory {
    private static volatile DatabaseFactory instance;
    
    public static DatabaseFactory getInstance() {
        if (instance == null) {  // Первая проверка без блокировки
            synchronized (DatabaseFactory.class) {
                if (instance == null) {  // Вторая проверка в блокировке
                    instance = new DatabaseFactory();
                }
            }
        }
        return instance;
    }
}

3. Синхронизированные сборки и утилиты

// Collections.synchronizedList использует синхронизацию класса
public class Collections {
    public static <T> List<T> synchronizedList(List<T> list) {
        return new SynchronizedList<>(list, MUTEX);
    }
}

// Использование
List<String> syncList = Collections.synchronizedList(new ArrayList<>());

4. Управление общим ресурсом

public class ResourcePool {
    private static int maxConnections = 10;
    private static int usedConnections = 0;
    
    public static synchronized void acquireConnection() {
        if (usedConnections >= maxConnections) {
            throw new RuntimeException("Нет свободных соединений");
        }
        usedConnections++;
    }
    
    public static synchronized void releaseConnection() {
        usedConnections--;
    }
}

Механизм синхронизации класса

За кулисами Java использует Class объект:

// Эти два способа эквивалентны:
public static synchronized void method() { }

// Аналог:
public static void method() {
    synchronized (MyClass.class) {  // Получаем Class объект
        // код
    }
}

Производительность и альтернативы

Проблема синхронизации класса:

• Блокирует весь класс, не отдельные данные
• Может привести к контенции (bottleneck)
• Снижает параллелизм

Современные альтернативы:

// 1. AtomicInteger для счётчиков
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();  // Безопаснее и быстрее

// 2. ConcurrentHashMap вместо synchronized Map
ConcurrentMap<String, Value> map = new ConcurrentHashMap<>();

// 3. ReentrantReadWriteLock для чтения/записи
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

// 4. volatile для простых полей
private static volatile boolean flag;

Итоговая рекомендация

Синхронизация класса нужна когда:

• Несколько потоков обращаются к одному статическому ресурсу
• Нужна атомарность операций
• Используется Singleton или Factory pattern

Но в современной Java предпочитайте:

• java.util.concurrent классы
• Atomic* для примитивов
• ConcurrentHashMap, CopyOnWriteArrayList
• Избегайте синхронизации, используя immutable объекты