Битва за скорость: может ли Java догнать Rust и C++?

// Пример использования Vector API для увеличения производительности
var a = FloatVector.fromArray(SPECIES, arrayA, 0);
var b = FloatVector.fromArray(SPECIES, arrayB, 0);
var c = a.mul(b).add(a); // SIMD-оптимизированный код

// До оптимизации - объект создаётся в куче
Point compute() {
    Point p = new Point(calculateX(), calculateY());
    return p;
}
 
// После оптимизации C2 - без выделения в куче!
Point compute() {
    int x = calculateX();
    int y = calculateY();
    return new Point(x, y); // может быть оптимизировано до стековой аллокации
}

// В C++ мы можем точно контролировать, когда объект уничтожится
{
    std::unique_ptr<HeavyResource> resource = std::make_unique<HeavyResource>();
    resource->process();
} // Объект гарантированно освобожден здесь
 
// В Java мы можем лишь намекнуть сборщику мусора
{
    HeavyResource resource = new HeavyResource();
    resource.process();
    resource = null; // Лишь намек для GC, не гарантия
}

// В Java структуры данных часто содержат дополнительные указатели
class Node {
    int value;
    Node next; // Указатель на следующий узел
}
 
// Массив из 1000 узлов создаст 1000 отдельных объектов с указателями

// В этом цикле C2-компилятор сделает оптимизацию только после 
// нескольких тысяч итераций
for (int i = 0; i < 1_000_000; i++) {
    result += performComplexCalculation(i);
}

// Анти-паттерн в Java: использование исключений как части нормальной 
// логики работы программы
try {
    int value = map.get(key);
    process(value);
} catch (NullPointerException e) {
    // Ключ не найден, делаем что-то другое
}

// Традиционный подход с JNI
public native long sumArray(long[] array, int length);
 
// Современный подход с FFM API
MethodHandle sumArray = linker.downcallHandle(
    lookup.lookup("sumArray"),
    MethodType.methodType(long.class, MemorySegment.class, int.class)
);
long result = (long) sumArray.invokeExact(arraySegment, length);

// Традиционное умножение матриц
for (int i = 0; i < size; i++)
    for (int j = 0; j < size; j++)
        for (int k = 0; k < size; k++)
            c[i][j] += a[i][k] * b[k][j];
 
// С использованием Vector API
var va = FloatVector.fromArray(SPECIES, rowA, 0);
var vb = FloatVector.fromArray(SPECIES, colB, 0);
sum = sum.add(va.mul(vb));

// Традиционная работа с объектами в Java
Point3D[] points = new Point3D[1000];
for (int i = 0; i < 1000; i++)
    points[i] = new Point3D(i, i*2, i*3); // Каждый объект в отдельном месте в памяти

// С Value Types (синтаксис упрощен)
value class Point3D {
    int x, y, z;
}
 
Point3D[] points = new Point3D[1000]; // Все точки в непрерывном блоке памяти!

// Традиционно: упаковка и распаковка на каждой операции
List<Integer> list = new ArrayList<>();
list.add(42); // boxing
int x = list.get(0); // unboxing
 
// С специализированными обобщениями
List<int> list = new ArrayList<>(); // Примитивы без упаковки

// Традиционный подход с потоками ОС
ExecutorService executor = Executors.newFixedThreadPool(200);
for (int i = 0; i < 10_000; i++) {
    executor.submit(() -> processRequest()); // Максимум 200 одновременных запросов
}
 
// С виртуальными потоками
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 1_000_000; i++) {
        executor.submit(() -> processRequest()); // Миллион одновременных запросов!
    }
}

// Запуск ZGC с заданным максимальным временем паузы
java -XX:+UseZGC -XX:ZCollectionInterval=5000 -XX:ZAllocationSpikeTolerance=5.0 -Xmx100g MyApplication

// Запуск Shenandoah для критичного к латентности приложения
java -XX:+UseShenandoahGC -XX:ShenandoahGCHeuristics=compact MyApplication

// Аллокация множества мелких объектов - антипаттерн!
List<Point> points = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
    points.add(new Point(i, i)); // Миллион отдельных аллокаций!
}
 
// Более эффективный подход - минимизация аллокаций
int[] xCoords = new int[1_000_000];
int[] yCoords = new int[1_000_000];
for (int i = 0; i < 1_000_000; i++) {
    xCoords[i] = i;
    yCoords[i] = i;
}

// До Java 16
public final class Point {
    private final int x;
    private final int y;
    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    // Геттеры, equals, hashCode, toString...
}
 
// С Java 16
record Point(int x, int y) {} // Всё то же самое, но компактнее и производительнее

// До Java 9: ~20 байт заголовок + 2 * 10 = 40 байт (всего ~60 байт)
String asciiOnly = "0123456789";
 
// После Java 9: ~20 байт заголовок + 1 * 10 = 10 байт (всего ~30 байт)
// Память экономится автоматически, когда возможно!

// Сравнительные результаты обработки больших графов (нормализованы, ниже лучше)
C++ (оптимизированный): 1.00
Java (с продвинутыми оптимизациями): 1.15
Rust (стандартный): 1.05
Python: 22.40

// Время холодного старта и выполнения короткой задачи (мс)
C++: 12
Rust: 15
Java (стандартная JVM): 250
Java (GraalVM Native Image): 25

// Поиск с помощью регулярных выражений в большом текстовом файле
// Время выполнения в мс, меньше лучше
// C++17 с RE2: 145
// Java с java.util.regex и JIT: 152
// Rust с regex: 130

// Умножение матриц 1000x1000 (время в миллисекундах)
// C++ с ручной оптимизацией: 85 
// Java с "наивной" реализацией: 320
// Java с Vector API: 105
// Rust с rayon: 90

// Антипаттерн бенчмаркинга Java
public static void main(String[] args) {
    long start = System.nanoTime();
    runTest(); // Первый запуск, JIT ещё не оптимизировал!
    long end = System.nanoTime();
    System.out.println("Time: " + (end - start) / 1_000_000 + "ms");
}

public static void main(String[] args) {
    // Прогрев JIT
    for (int i = 0; i < 10_000; i++) {
        runTest();
    }
    
    // Реальное измерение после прогрева
    long start = System.nanoTime();
    for (int i = 0; i < 1000; i++) {
        runTest();
    }
    long end = System.nanoTime();
    System.out.println("Avg time: " + (end - start) / 1_000_000 / 1000.0 + "ms");
}

// Время обработки 10 млн записей (меньше лучше)
Java + G1GC: 5.2 секунды
Java + ZGC: 5.7 секунды (но с паузами < 1мс)
Java + SerialGC: 7.1 секунды
C++: 4.8 секунды

// Java: отображение файла в память
try (FileChannel channel = FileChannel.open(Path.of("huge.bin"), StandardOpenOption.READ)) {
    MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());
    // Работа с буфером
}

// Гипотетический пример автоптимизации будущего
@OptimizeWithML // Аннотация для включения ML-оптимизаций
public void performCalculation(Matrix a, Matrix b) {
    // JVM автоматически выберет лучший алгоритм и распараллеливание
    return a.multiply(b); 
}