Как решить медленную скорость доступа после синхронизации объектов класса?

Оптимизация доступа к синхронизированным объектам

Медленный доступ после синхронизации — одна из самых распространённых проблем производительности в многопоточных Java приложениях. Это происходит из-за конфликтов блокировок, контекстных переключений и кэш-нарушений.

Причины медленного доступа

1. Избыточная синхронизация:

public synchronized void processData(List<String> items) {
    for (String item : items) {
        validate(item);
        transform(item);
        cache(item);
    }
}

public void processData(List<String> items) {
    for (String item : items) {
        validate(item);
        transform(item);
        synchronized(cacheLock) {
            cache(item);
        }
    }
}

2. Coarse-grained vs Fine-grained locks:

class UserDatabase {
    private final Object readLock = new Object();
    private final Object writeLock = new Object();
    
    public User getUser(Long id) {
        synchronized(readLock) {
            return repository.findById(id);
        }
    }
    
    public void updateUser(User user) {
        synchronized(writeLock) {
            repository.save(user);
        }
    }
}

Решение 1: ReadWriteLock для read-heavy нагрузок

Если читаем чаще, чем пишем — ReadWriteLock дает огромный прирост:

class UserCache {
    private final Map<Long, User> cache = new HashMap<>();
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    
    public User getUser(Long id) {
        lock.readLock().lock();
        try {
            return cache.get(id);
        } finally {
            lock.readLock().unlock();
        }
    }
    
    public void putUser(Long id, User user) {
        lock.writeLock().lock();
        try {
            cache.put(id, user);
        } finally {
            lock.writeLock().unlock();
        }
    }
}

Решение 2: Segmented/Striped Locks

Разбиваем данные на сегменты с отдельными блокировками:

class SegmentedCache<K, V> {
    private static final int SEGMENTS = 16;
    private final Map<K, V>[] segments;
    private final Object[] locks;
    
    public int getSegment(K key) {
        return Math.abs(key.hashCode() % SEGMENTS);
    }
    
    public V get(K key) {
        int segment = getSegment(key);
        synchronized(locks[segment]) {
            return segments[segment].get(key);
        }
    }
}

Решение 3: ConcurrentHashMap

Map<String, Integer> slowMap = Collections.synchronizedMap(new HashMap<>());
ConcurrentHashMap<String, Integer> fastMap = new ConcurrentHashMap<>();
fastMap.put("key1", 1);

Решение 4: CopyOnWriteArrayList для редких writes

List<String> list = new CopyOnWriteArrayList<>();
list.add("item");
for (Listener listener : list) {
    listener.onEvent(event);
}

Решение 5: StampedLock

class OptimizedCache<K, V> {
    private final Map<K, V> data = new HashMap<>();
    private final StampedLock lock = new StampedLock();
    
    public V get(K key) {
        long stamp = lock.tryOptimisticRead();
        V value = data.get(key);
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                value = data.get(key);
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return value;
    }
}

Решение 6: Атомарные операции

class Counter {
    private final AtomicInteger count = new AtomicInteger(0);
    public void increment() { count.incrementAndGet(); }
}

Решение 7: ThreadLocal

private static final ThreadLocal<DateFormat> dateFormat = 
    ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));

public String formatDate(Date date) {
    return dateFormat.get().format(date);
}

Практический чеклист оптимизации

1. Измерь — используй JMH benchmarks, JFR
2. Сузь область синхронизации
3. Используй правильные структуры:
   • ConcurrentHashMap вместо synchronized Map
   • ReadWriteLock для read-heavy
   • StampedLock для максимального throughput
   • AtomicInteger вместо synchronized int
4. Профилируй — Java VisualVM покажет contention
5. Избегай nested locks

Правильный выбор синхронизационного механизма часто дает 10-100x прирост производительности.