Почему Hashtable Deprecated?

Почему Hashtable Deprecated?

Hashtable технически не помечена как deprecated (не имеет аннотации @Deprecated), однако она считается устаревшей и не рекомендуется к использованию в современной Java. Она остаётся в языке только для обратной совместимости с легаси кодом.

История Hashtable

Hashtable была одной из первых реализаций хеш-таблицы в Java, введена в версии Java 1.0 (1996 год). В то время это была основная структура данных для работы с key-value парами. Однако с появлением Java Collections Framework в Java 1.2 (1998 год) ситуация изменилась.

Основные причины, почему Hashtable устарела

1. Неправильный дизайн синхронизации

Hashtable синхронизирует весь объект целиком:

public synchronized V put(K key, V value) {
    // Весь метод synchronized
    // Во время операции put весь Hashtable заблокирован
}

public synchronized V get(Object key) {
    // Весь метод synchronized
    // Во время операции get весь Hashtable заблокирован
}

Проблема: Даже если вам нужен доступ только к разным "бакетам", весь Hashtable блокируется. Это создаёт узкое место (bottleneck) в многопоточных приложениях.

Пример неэффективности:

Поток 1: Хочет записать значение в bucket [0]
         Блокирует весь Hashtable

Поток 2: Хочет прочитать значение из bucket [10]
         ЖДЁТ! Весь Hashtable заблокирован

Это приводит к значительной потере производительности

2. ConcurrentHashMap — намного лучше

ConcurrentHashMap была создана в Java 1.5 специально для замены Hashtable:

// Hashtable: весь объект синхронизирован
public class Hashtable<K, V> {
    public synchronized V put(K key, V value) { }
    public synchronized V get(Object key) { }
}

// ConcurrentHashMap: используется сегментная блокировка (Segment Lock)
public class ConcurrentHashMap<K, V> {
    // До Java 8: разделена на 16 сегментов, каждый со своей блокировкой
    // Java 8+: используется Node-level лocking (ещё более эффективно)
    
    public V put(K key, V value) {
        // Блокируется только сегмент, содержащий этот ключ
        // Другие потоки могут работать с другими сегментами
    }
}

Сравнение производительности:

// Hashtable: 1000 операций put, 10 потоков
Hashtable<String, String> ht = new Hashtable<>();
long start = System.currentTimeMillis();
// Среднее время: ~500ms (весь объект блокируется при каждой операции)

// ConcurrentHashMap: 1000 операций put, 10 потоков
ConcurrentHashMap<String, String> chm = new ConcurrentHashMap<>();
long start = System.currentTimeMillis();
// Среднее время: ~50ms (только один сегмент блокируется)

3. Несовместимость с Collections Framework

Hashtable не наследует Map интерфейс напрямую:

// Hashtable — наследует Dictionary (устаревший класс)
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V> {
    // Нарушает контракт Collections Framework
}

// HashMap — правильно реализует Map
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V> {
    // Полная совместимость с Collection Framework
}

// Это приводит к проблемам:
Hashtable<String, Integer> ht = new Hashtable<>();
ht.put(null, 1); // Выбросит NullPointerException!

HashMap<String, Integer> hm = new HashMap<>();
hm.put(null, 1); // Работает нормально

4. Не поддерживает null ключи и null значения

// Hashtable НЕ позволяет null ключи
Hashtable<String, String> ht = new Hashtable<>();
ht.put(null, "value"); // NullPointerException!

// HashMap позволяет null ключи и значения
HashMap<String, String> hm = new HashMap<>();
hm.put(null, "value"); // OK

// LinkedHashMap тоже поддерживает
LinkedHashMap<String, String> lhm = new LinkedHashMap<>();
lhm.put(null, "value"); // OK

5. Фиксированное разбиение на сегменты

В Hashtable разбиение на сегменты было фиксированным:

public class Hashtable<K,V> {
    private static final int DEFAULT_CAPACITY = 11;
    private static final float LOAD_FACTOR = 0.75f;
    
    // При достижении load factor, таблица расширяется в 2 раза + 1
    // Это неоптимально по сравнению с HashMap и ConcurrentHashMap
}

Сравнение Hashtable, HashMap и ConcurrentHashMap

Как правильно выбрать структуру данных

Однопоточный код: используй HashMap

// Однопоточное приложение или локальные переменные в методе
public class UserCache {
    private HashMap<String, User> cache = new HashMap<>();
    
    public void addUser(String id, User user) {
        cache.put(id, user);
    }
    
    public User getUser(String id) {
        return cache.get(id);
    }
}

Многопоточный код: используй ConcurrentHashMap

// Многопоточное приложение, общие ресурсы
public class SharedUserCache {
    private ConcurrentHashMap<String, User> cache = new ConcurrentHashMap<>();
    
    public void addUser(String id, User user) {
        cache.put(id, user);
    }
    
    public User getUser(String id) {
        return cache.get(id);
    }
    
    // Потокобезопасно!
    public int getCacheSize() {
        return cache.size();
    }
}

Если нужна синхронизация с HashMap: используй Collections.synchronizedMap()

// Синхронизированный HashMap если нужна полная блокировка
HashMap<String, String> hm = new HashMap<>();
Map<String, String> syncMap = Collections.synchronizedMap(hm);

// Но обычно лучше использовать ConcurrentHashMap
ConcurrentHashMap<String, String> chm = new ConcurrentHashMap<>();

Почему Hashtable остаётся в Java

Hashtable не удалили из Java по нескольким причинам:

1. Обратная совместимость — миллионы строк legacy кода используют Hashtable
2. Properties класс — наследует Hashtable, удаление сломало бы API
3. Удаление API — это очень опасно и редко делается в Java

// Properties наследует Hashtable (для обратной совместимости)
public class Properties extends Hashtable<Object, Object> {
    // ...
}

// Если бы мы удалили Hashtable, Properties перестала бы работать

Практический пример: когда вы встречаете Hashtable

// Старый код (ПЛОХО)
public class LegacyCache {
    private Hashtable<String, Data> cache = new Hashtable<>();
    
    public void cache(String key, Data value) {
        synchronized (cache) {  // Еще и ручная синхронизация!
            cache.put(key, value);
        }
    }
}

// Современный код (ХОРОШО)
public class ModernCache {
    private ConcurrentHashMap<String, Data> cache = new ConcurrentHashMap<>();
    
    public void cache(String key, Data value) {
        cache.put(key, value);  // Уже потокобезопасно
    }
}

Миграция с Hashtable

Если вы нашли Hashtable в старом коде, замените его:

// Было
private Hashtable<String, Integer> map = new Hashtable<>();

// Если однопоточно:
private HashMap<String, Integer> map = new HashMap<>();

// Если многопоточно:
private ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// Если нужна синхронизация всего объекта (редко):
private Map<String, Integer> map = Collections.synchronizedMap(new HashMap<>());

Итоговый чеклист

✓ Никогда не используй Hashtable в новом коде ✓ Для однопоток: HashMap ✓ Для многопоток: ConcurrentHashMap ✓ ConcurrentHashMap намного более эффективна чем Hashtable ✓ Hashtable не поддерживает null ключи/значения ✓ Properties наследует Hashtable (но это не твоя проблема) ✓ Если встретил Hashtable в legacy коде — замени на ConcurrentHashMap

Hashtable — это реликт прошлого, оставленный только для обратной совместимости. В современной Java используй HashMap для однопоточного кода и ConcurrentHashMap для многопоточного.