Дайте определение понятию "процесс" и "поток" в контексте Java.

Процесс и поток в контексте Java

Процесс и поток — это фундаментальные концепции многопоточного программирования. Хотя они часто используются рядом, это совершенно разные абстракции с различными характеристиками. Понимание их различий критично для разработки эффективных и надёжных многопоточных приложений.

Процесс (Process)

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

Основные характеристики процесса:

• Независимость: Процессы полностью изолированы друг от друга
• Собственная память: Каждый процесс имеет отдельное адресное пространство
• Тяжелые ресурсы: Создание и переключение между процессами требует значительных системных ресурсов
• Взаимодействие: Процессы взаимодействуют через межпроцессное взаимодействие (IPC)
• Управление ОС: Полностью управляются операционной системой

Пример с использованием Java Runtime для запуска внешних процессов:

import java.io.IOException;

public class ProcessExample {
    public static void main(String[] args) throws IOException {
        // Запуск внешнего процесса (например, notepad в Windows)
        ProcessBuilder pb = new ProcessBuilder("notepad.exe");
        Process process = pb.start();
        
        System.out.println("Процесс запущен с PID: " + process.pid());
        
        // Ожидание завершения процесса
        try {
            int exitCode = process.waitFor();
            System.out.println("Процесс завершился с кодом: " + exitCode);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Поток (Thread)

Поток — это легковесная единица выполнения внутри процесса. Несколько потоков внутри одного процесса разделяют одно адресное пространство памяти, но выполняются независимо друг от друга.

Основные характеристики потока:

• Легкость создания: Потоки создаются намного быстрее, чем процессы
• Общая память: Все потоки в процессе разделяют одну память
• Быстрое переключение: Переключение между потоками происходит быстрее
• Конкурентность: Несколько потоков могут выполняться одновременно
• Управление JVM: Потоки управляются виртуальной машиной Java

Пример создания потока:

// Способ 1: Наследование класса Thread
public class MyThread extends Thread {
    private String name;
    
    public MyThread(String name) {
        this.name = name;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + " - итерация " + i);
            try {
                Thread.sleep(1000); // Пауза 1 секунда
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadExample1 {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread("Поток-1");
        MyThread thread2 = new MyThread("Поток-2");
        
        thread1.start(); // Запускаем поток
        thread2.start();
    }
}

Реализация интерфейса Runnable (рекомендуется)

// Способ 2: Реализация интерфейса Runnable (предпочтительнее)
public class MyRunnable implements Runnable {
    private String name;
    
    public MyRunnable(String name) {
        this.name = name;
    }
    
    @Override
    public void run() {
        System.out.println(name + " начал работу");
        for (int i = 0; i < 3; i++) {
            System.out.println(name + " выполняет задачу " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(name + " завершил работу");
    }
}

public class ThreadExample2 {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable("Рабочий-1"));
        Thread thread2 = new Thread(new MyRunnable("Рабочий-2"));
        Thread thread3 = new Thread(new MyRunnable("Рабочий-3"));
        
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

Использование Lambda выражений (Java 8+)

public class ThreadLambdaExample {
    public static void main(String[] args) {
        // С использованием lambda выражения
        Thread thread = new Thread(() -> {
            System.out.println("Выполнение задачи в потоке: " + Thread.currentThread().getName());
            for (int i = 0; i < 3; i++) {
                System.out.println("Итерация: " + i);
            }
        });
        
        thread.start();
    }
}

Жизненный цикл потока

Поток проходит через несколько состояний:

public class ThreadLifecycleExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                System.out.println("Поток выполняется...");
                Thread.sleep(2000);
                System.out.println("Поток завершён");
            } catch (InterruptedException e) {
                System.out.println("Поток был прерван");
            }
        });
        
        // NEW - Состояние: поток создан, но не начался
        System.out.println("Состояние: " + thread.getState());
        
        // Запуск потока
        thread.start();
        
        // RUNNABLE/RUNNING - Поток выполняется
        System.out.println("Состояние: " + thread.getState());
        
        // TIMED_WAITING - Поток в sleep
        Thread.sleep(500);
        System.out.println("Состояние: " + thread.getState());
        
        // Ждём завершения
        thread.join(); // Текущий поток ждёт завершения целевого потока
        
        // TERMINATED - Поток завершён
        System.out.println("Состояние: " + thread.getState());
    }
}

Сравнение процесса и потока

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

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultithreadedServer {
    public static void main(String[] args) {
        // ExecutorService управляет пулом потоков
        ExecutorService executor = Executors.newFixedThreadPool(5);
        
        // Подача задач на выполнение
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Задача " + taskId + " выполняется в потоке: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Задача " + taskId + " завершена");
            });
        }
        
        // Завершение работы executor
        executor.shutdown();
    }
}

Ключевые выводы

• Процесс — это тяжёлая, независимая единица выполнения, управляемая ОС
• Поток — это лёгкая единица выполнения внутри процесса, управляемая JVM
• Java позволяет легко работать с потоками благодаря встроенной поддержке
• Использование потоков требует осторожности с синхронизацией и доступом к общим ресурсам