Какие способы позволяют экономить память?

Способы экономии памяти в Java

Оптимизация памяти — критическая задача при разработке высоконагруженных систем. Java имеет встроенный garbage collector, но разработчик должен понимать, как эффективнее использовать heap память.

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

Используйте примитивы вместо объектов-оберток:

// Плохо - каждое int обёрнуто в Integer объект
List<Integer> numbers = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
    numbers.add(i); // Создаёт Integer объект каждый раз
}
// Использует ~16MB только для объектов

// Хорошо - примитивные типы
int[] numbers = new int[1_000_000];
// Использует ~4MB

// Или библиотека для примитивных коллекций
IntList numbers = new IntArrayList();
for (int i = 0; i < 1_000_000; i++) {
    numbers.add(i); // Без обёртки
}

Выбирайте правильные коллекции:

// HashSet vs LinkedHashSet
Set<String> hash = new HashSet<>(); // O(1) поиск, меньше памяти
Set<String> linked = new LinkedHashSet<>(); // Сохраняет порядок, больше памяти

// HashMap vs LinkedHashMap
Map<String, String> hash = new HashMap<>(); // Компактнее
Map<String, String> linked = new LinkedHashMap<>(); // Больше памяти

// ArrayList vs LinkedList
List<String> array = new ArrayList<>(); // Лучше для памяти, O(1) доступ
List<String> linked = new LinkedList<>(); // Хуже для памяти, O(n) поиск

2. Избегайте утечек памяти

Проблема с static коллекциями:

// Плохо - коллекция растёт бесконечно
public class Cache {
    private static List<String> cache = new ArrayList<>();
    
    public void add(String value) {
        cache.add(value); // Никогда не удаляется!
    }
}

// Хорошо - с лимитом
public class BoundedCache {
    private static LinkedList<String> cache = new LinkedList<>();
    private static final int MAX_SIZE = 1000;
    
    public void add(String value) {
        cache.add(value);
        if (cache.size() > MAX_SIZE) {
            cache.removeFirst(); // Удаляем старые
        }
    }
}

// Или используйте WeakHashMap для кэша
Map<String, byte[]> cache = new WeakHashMap<>();

Проблема с неправильным обходом коллекций:

// Плохо - создаёт Iterator объект
for (String item : list) {
    System.out.println(item);
}

// Хорошо - прямой доступ по индексу
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

// Или используйте stream с операциями
list.stream().forEach(System.out::println);

3. Интернирование строк

Дублирование строк в памяти:

// Плохо - создаёт миллион отдельных String объектов
List<String> strings = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
    String name = "John" + i; // Новый объект каждый раз
    strings.add(name);
}

// Хорошо - используйте intern() для повторяющихся значений
List<String> strings = new ArrayList<>();
String prefix = "John".intern(); // Один объект в String pool
for (int i = 0; i < 1_000_000; i++) {
    String name = (prefix + i).intern();
    strings.add(name);
}

// Или избегайте создания строк
char[] prefix = "John".toCharArray(); // Один раз
List<String> strings = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
    String name = new String(prefix) + i;
    strings.add(name);
}

4. Ленивая инициализация

Создавайте объекты только когда нужны:

// Плохо - всегда создаёт объект
class User {
    private Address address = new Address();
}

// Хорошо - создаёт только при доступе
class User {
    private Address address;
    
    public Address getAddress() {
        if (address == null) {
            address = new Address();
        }
        return address;
    }
}

// Или используйте Supplier для более явной ленивости
class User {
    private Supplier<Address> addressSupplier = () -> new Address();
    private Address address;
    
    public Address getAddress() {
        if (address == null) {
            address = addressSupplier.get();
        }
        return address;
    }
}

5. Переиспользуйте объекты (Object Pool)

Избегайте создания множества временных объектов:

// Плохо - создаёт StringBuilder каждый раз
for (int i = 0; i < 1_000_000; i++) {
    StringBuilder sb = new StringBuilder();
    sb.append("Value: ").append(i).append("ms");
    String result = sb.toString();
}

// Хорошо - переиспользуйте StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1_000_000; i++) {
    sb.setLength(0); // Очищаем, переиспользуем
    sb.append("Value: ").append(i).append("ms");
    String result = sb.toString();
}

// Object pool для дорогостоящих объектов
queue<ByteBuffer> bufferPool = new ConcurrentLinkedQueue<>();

ByteBuffer allocate() {
    ByteBuffer buffer = bufferPool.poll();
    if (buffer == null) {
        buffer = ByteBuffer.allocate(1024);
    }
    return buffer;
}

void release(ByteBuffer buffer) {
    buffer.clear();
    bufferPool.add(buffer);
}

6. Оптимизируйте размер объектов

Используйте byte вместо String где возможно:

// Плохо для больших объёмов
List<String> hexData = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
    hexData.add(Integer.toHexString(i)); // Строка для каждого числа
}

// Хорошо - компактнее
List<Integer> data = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
    data.add(i); // Прямой примитив
}

Избегайте больших объектов в памяти:

// Плохо - держим весь файл в памяти
String fileContent = Files.readString(Paths.get("huge_file.txt"));

// Хорошо - читаем по частям (streaming)
Files.lines(Paths.get("huge_file.txt"))
    .forEach(line -> processLine(line));

// Или используйте BufferedReader
BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
String line;
while ((line = reader.readLine()) != null) {
    processLine(line);
}

7. Используйте кэширование с правильной стратегией

Правильное кэширование экономит память:

// Хорошо - автоматическое удаление через timeout
LoadingCache<String, String> cache = CacheBuilder.newBuilder()
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .maximumSize(1000)
    .build(new CacheLoader<String, String>() {
        public String load(String key) {
            return getValueExpensively(key);
        }
    });

// Используйте SoftReference для более мягкого кэширования
Map<String, SoftReference<byte[]>> cache = new ConcurrentHashMap<>();

byte[] getOrLoad(String key) {
    SoftReference<byte[]> ref = cache.get(key);
    if (ref != null && ref.get() != null) {
        return ref.get();
    }
    byte[] data = loadData(key);
    cache.put(key, new SoftReference<>(data));
    return data;
}

8. Правильный выбор типов данных

Используйте более компактные типы:

// Плохо
class User {
    private Long id; // 16 байт с заголовком объекта
    private Long createdAt; // 16 байт
    private Integer status; // 16 байт
}

// Хорошо
class User {
    private long id; // 8 байт
    private long createdAt; // 8 байт
    private int status; // 4 байта
}

9. Профилирование и мониторинг

Используйте JVM флаги для мониторинга:

# Вывести использование памяти
java -Xmx1024m -verbose:gc MyApp

# Использовать G1GC для больших heap'ов
java -XX:+UseG1GC -Xmx8g MyApp

# Найти утечки памяти
java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp MyApp

Выводы

Основные способы экономии памяти:

1. Используйте примитивные типы вместо оберток
2. Выбирайте правильные структуры данных
3. Избегайте утечек через static коллекции
4. Применяйте ленивую инициализацию
5. Переиспользуйте объекты через пулы
6. Читайте файлы потоком, не загружайте в памяти целиком
7. Используйте сжатие данных где возможно
8. Профилируйте код для выявления проблем
9. Выбирайте правильный garbage collector

Для высоконагруженных систем экономия памяти на 30-50% может дать значительный прирост производительности.