В чем разница между потоками в Java и потоками в операционной системе?

Java потоки vs ОС потоки

Это важное различие для понимания многопоточности в Java.

Что такое ОС потоки?

Потоки операционной системы — это независимые единицы выполнения, управляемые ядром ОС. Каждый поток имеет свой стек вызовов и контекст выполнения.

Что такое Java потоки?

Java потоки — это объекты класса Thread, которые представляют логические единицы выполнения в рамках процесса JVM. Java потоки отображаются на потоки ОС.

Ключевые различия

Как работает отображение?

В классической Java каждый Java поток создаёт один ОС поток. Это означает:

// Создаём Java поток
Thread thread = new Thread(() -> {
    System.out.println("Выполняется");
});
thread.start();

// Под капотом создаётся ОС поток
// JVM -> ОС -> Ядро ОС -> выделение ресурсов ядра

Управление потоками в Java

Java предоставляет удобный API для работы с потоками:

// Создание потока
Thread t = new Thread(() -> {
    System.out.println("Работа");
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
});

// Запуск
t.start();

// Ожидание завершения
t.join();

// Управление приоритетом
t.setPriority(Thread.MAX_PRIORITY);

ОС управление потоками

Опер. система сама:

• Переключает контекст между потоками
• Распределяет процессорное время
• Управляет приоритетами
• Синхронизирует доступ к ресурсам

Стоимость создания потока

Создание Java потока требует:

1. Выделение памяти для стека (обычно 1-2 MB)
2. Создание ОС потока (дорогое)
3. Регистрацию в расписании ядра
4. Переключение контекста

Поэтому количество потоков ограничено ОС и доступной памятью.

Синхронизация в Java

Java предоставляет механизмы синхронизации, которые работают через ОС:

public class Counter {
    private int value = 0;
    
    // synchronized использует монитор Java объекта
    // который отображается на ОС механизмы синхронизации
    public synchronized void increment() {
        value++;
    }
    
    public synchronized int getValue() {
        return value;
    }
}

Планирование потоков

В Java можно установить приоритет:

Thread high = new Thread(() -> System.out.println("Высокий"));
Thread low = new Thread(() -> System.out.println("Низкий"));

high.setPriority(Thread.MAX_PRIORITY);    // 10
low.setPriority(Thread.MIN_PRIORITY);     // 1

high.start();
low.start();

Однако это только рекомендация ОС. Реальное планирование зависит от ОС.

Виртуальные потоки (Java 19+)

Project Loom вводит виртуальные потоки — более лёгкую альтернативу:

// Виртуальные потоки — M:N отображение
// Тысячи виртуальных потоков на несколько ОС потоков

var vThread = Thread.ofVirtual().start(() -> {
    System.out.println("Виртуальный поток");
});

// Можно создать миллионы виртуальных потоков!
for (int i = 0; i < 1_000_000; i++) {
    Thread.ofVirtual().start(() -> {
        // Работа
    });
}

Практический пример

public class ThreadExample {
    public static void main(String[] args) throws InterruptedException {
        // Два потока конкурируют за CPU
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                Math.sqrt(i);
            }
            System.out.println("Поток 1 завершён");
        });
        
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                Math.pow(i, 2);
            }
            System.out.println("Поток 2 завершён");
        });
        
        long start = System.currentTimeMillis();
        
        t1.start();
        t2.start();
        
        t1.join();
        t2.join();
        
        long duration = System.currentTimeMillis() - start;
        System.out.println("Время: " + duration + " ms");
    }
}

Итоговое сравнение

Java потоки — это АБСТРАКЦИЯ над ОС потоками. Java предоставляет:

• Переносимый API для работы с потоками
• Встроенную синхронизацию через synchronized
• Удобное управление жизненным циклом потока

ОС потоки — это:

• Базовые единицы выполнения на уровне ядра
• Реальное распределение процессорного времени
• Механизмы синхронизации (mutex, semaphore)
• Ограниченное количество доступных потоков

Понимание этого отображения критически важно для написания эффективного многопоточного кода в Java.