Как реализована работа с памятью в других ЯП?

Управление памятью в различных языках программирования

Разные языки подходят к управлению памятью по-разному. Это влияет на производительность, безопасность и удобство разработки.

1. JavaScript / TypeScript (сборка мусора)

Автоматическое управление через Garbage Collector (GC):

// Память автоматически очищается
let user = { name: "Иван", age: 30 };
let ref = user;
user = null; // Если нет других ссылок, объект удалится GC

// Memory leak - забыли удалить слушатель
const element = document.getElementById("btn");
element.addEventListener("click", function handler() {
  // Если не удалить слушатель, объект останется в памяти
  console.log("Click");
});
// Правильно:
element.removeEventListener("click", handler);

// WeakMap для слабых ссылок (не препятствует GC)
const cache = new WeakMap();
const obj = { id: 1 };
cache.set(obj, "value");
// Когда obj удалится из памяти, запись в WeakMap тоже удалится

Минусы сборки мусора

• Непредсказуемые паузы (GC может остановить всё)
• Дополнительный оверхед памяти
• Сложно оптимизировать критичные по времени участки

Плюсы

• Безопасность (нет buffer overflow, use-after-free)
• Разработчик не заботится об очистке

2. C / C++ (ручное управление)

Полный контроль, но полная ответственность:

// C - malloc/free
int *arr = (int *)malloc(10 * sizeof(int));
arr[0] = 42;
free(arr); // ОБЯЗАТЕЛЬНО освободить!
arr = NULL; // Best practice - избежать use-after-free

// C++ - new/delete
int *ptr = new int(42);
delete ptr;
ptr = nullptr;

// Smart pointers (RAII паттерн) - безопаснее
std::unique_ptr<int> smartPtr = std::make_unique<int>(42);
// Автоматически удалится при выходе из scope

Проблемы

// Memory leak - забыли free
int *leaked = (int *)malloc(sizeof(int));
leaked = NULL; // Потеряли адрес, не можем освободить

// Dangling pointer - использование после delete
int *ptr = new int(42);
delete ptr;
printf("%d", *ptr); // CRASH - undefined behavior

// Double free - удаление дважды
int *ptr = new int(42);
delete ptr;
delete ptr; // ERROR!

Плюсы

• Максимальная производительность
• Полный контроль над памятью
• Нет GC пауз

3. Java (сборка мусора с оптимизациями)

Цели: безопасность Java + производительность C:

// Автоматическая сборка мусора
String user = "Ivan"; // Создается в heap
user = null; // Будет удалена GC

// Явное управление (редко)
System.gc(); // Просьба к JVM запустить GC
System.runFinalization(); // Запустить финализаторы

// Try-with-resources - автоматическое закрытие
try (FileReader reader = new FileReader("file.txt")) {
    // Ресурс автоматически закроется
    reader.read();
} catch (IOException e) {
    e.printStackTrace();
}

Особенности JVM

• Generational GC - молодые объекты удаляются чаще
• JIT компиляция - оптимизация во время выполнения
• Stack для примитивов, Heap для объектов

// Stack - быстро, автоматически очищается
int x = 42;
String name = "Ivan"; // Ссылка в stack, объект в heap

// Heap - медленнее, управляется GC
Object obj = new Object(); // В heap

4. Python (сборка мусора + reference counting)

Комбинированный подход:

# Reference counting
import sys

obj = [1, 2, 3]
print(sys.getrefcount(obj))  # Количество ссылок

ref1 = obj  # refcount = 2
ref2 = obj  # refcount = 3

del ref1  # refcount = 2

# Когда refcount = 0, объект удаляется

# Циклические ссылки требуют GC
class Node:
    def __init__(self):
        self.next = None

a = Node()
b = Node()
a.next = b
b.next = a  # Цикл - reference counting не поможет

del a
del b
# GC (garbage collector) найдет цикл и удалит

# Явное управление
import gc
gc.collect()  # Запустить сборку мусора

with open("file.txt") as f:
    data = f.read()  # Ресурс автоматически закроется

5. Rust (ownership system)

Новый подход - безопасность без GC:

// Ownership - только один владелец
let s1 = String::from("hello");
let s2 = s1; // s1 больше не владеет значением
// println!("{}", s1); // ERROR - s1 больше не владеет
println!("{}", s2); // OK

// Borrowing (ссылка)
let s1 = String::from("hello");
let s2 = &s1; //借用, не берем владение
println!("{}", s1); // OK - s1 еще владеет
println!("{}", s2); // OK

// Mutable reference (изменяемая ссылка)
let mut s = String::from("hello");
let r1 = &mut s;
r1.push_str(" world");
// let r2 = &mut s; // ERROR - две изменяемые ссылки
println!("{}", r1);

// Stack vs Heap
let x = 42;  // i32 - Stack
let s = String::from("hello"); // String - Heap
// При выходе из scope, s.drop() вызывается автоматически

Плюсы Rust

• Безопасность памяти без GC
• Нет race conditions (thread safety)
• Производительность как C/C++

6. Go (сборка мусора + escape analysis)

Прагматичный подход:

package main

// Автоматическое выявление - stack или heap
func makeUser(name string) *User {
    user := User{Name: name} // Escape analysis определит, что нужен heap
    return &user // Вернуть указатель
}

// Defer - гарантирует очистку ресурсов
func readFile(filename string) {
    file, _ := os.Open(filename)
    defer file.Close() // Выполнится в конце функции
    
    // Чтение файла
}

// Goroutines - управление памятью для конкурентности
func main() {
    go func() {
        // Отдельная горутина, автоматически управляется GC
    }()
}

Сравнение в таблице

Когда что использовать

// JavaScript - web приложения, быстрая разработка
const app = express();
app.get("/", (req, res) => res.send("Hello"));

// C++ - системное ПО, high-performance
// Игры, embedded системы

// Rust - когда нужна безопасность + скорость
// Критичные по безопасности системы

// Python - data science, автоматизация
// Когда скорость разработки важнее скорости выполнения

// Java - enterprise приложения
// Когда нужна масштабируемость и стабильность

Ключевые моменты

• Автоматическое управление (GC) безопаснее, но медленнее
• Ручное управление (C/C++) быстрее, но опаснее
• Rust предлагает best of both worlds через ownership
• Понимание управления памятью критично для оптимизации
• JavaScript рекомендует использовать WeakMap/WeakSet для предотвращения утечек