В чем различия потоков и процессов?

Различия потоков и процессов

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

Процесс (Process)

Процесс — это самостоятельное приложение с собственной памятью, ресурсами и окружением.

// Создание нового процесса
var process = new ProcessStartInfo
{
    FileName = "notepad.exe",
    Arguments = "file.txt"
};

Process.Start(process);

// Взаимодействие между процессами
var proc = Process.Start("cmd.exe");
proc.StandardInput.WriteLine("dir");
var output = proc.StandardOutput.ReadToEnd();
Console.WriteLine(output);

Поток (Thread)

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

// Создание нового потока
var thread = new Thread(() =>
{
    Console.WriteLine($"Running in thread {Thread.CurrentThread.ManagedThreadId}");
    Thread.Sleep(1000);
});

thread.Start();
thread.Join(); // Ждем завершения

// Несколько потоков
var threads = new List<Thread>();
for (int i = 0; i < 5; i++)
{
    var t = new Thread(() => Console.WriteLine($"Thread {i}"));
    threads.Add(t);
    t.Start();
}

foreach (var t in threads)
    t.Join();

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

Пример: Параллелизм потоков

public class DataProcessor
{
    private List<int> _data = Enumerable.Range(1, 1000).ToList();
    private long _sum = 0;
    private readonly object _lock = new();

    public void ProcessWithThreads()
    {
        var threads = new List<Thread>();
        int threadCount = 4;
        int itemsPerThread = _data.Count / threadCount;

        for (int t = 0; t < threadCount; t++)
        {
            int start = t * itemsPerThread;
            int end = (t + 1) * itemsPerThread;

            var thread = new Thread(() =>
            {
                long localSum = 0;
                for (int i = start; i < end; i++)
                    localSum += _data[i];

                lock (_lock)
                {
                    _sum += localSum;
                }
            });
            threads.Add(thread);
            thread.Start();
        }

        foreach (var t in threads)
            t.Join();

        Console.WriteLine($"Sum: {_sum}");
    }
}

Пример: Взаимодействие процессов

// Процесс 1: Отправитель
var serverProcess = Process.Start(new ProcessStartInfo
{
    FileName = "server.exe",
    RedirectStandardInput = true,
    RedirectStandardOutput = true,
    UseShellExecute = false
});

serverProcess.StandardInput.WriteLine("START");
var response = serverProcess.StandardOutput.ReadLine();
Console.WriteLine(response);

// Процесс 2: Получатель (в server.exe)
// var command = Console.ReadLine(); // Получает "START"
// Console.WriteLine("Server started");

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

Потоки (Threads):

• Асинхронные операции (I/O, сеть)
• Параллельная обработка данных
• Одновременные операции в одном приложении
• UI-отзывчивость

// Асинхронная загрузка файла
var thread = new Thread(() =>
{
    var data = File.ReadAllBytes("largefile.bin");
    ProcessData(data);
});
thread.IsBackground = true;
thread.Start();
Console.WriteLine("UI остается отзывчивым");

Процессы (Processes):

• Запуск внешних приложений
• Изоляция (сбой одного не повлияет на других)
• Разные версии .NET
• Повышенная безопасность

// Запуск обработки в отдельном процессе
Process.Start("DataProcessor.exe", "input.csv output.csv");

ThreadPool и Task (современный подход)

// ThreadPool автоматически управляет потоками
ThreadPool.QueueUserWorkItem(_ =>
{
    Console.WriteLine("Work item executed");
});

// Task (рекомендуется)
await Task.Run(() =>
{
    Console.WriteLine("Task executed");
});

// Параллельная обработка
await Parallel.ForEachAsync(Enumerable.Range(1, 100), async (item, ct) =>
{
    await ProcessItemAsync(item);
});

Производительность

• Процесс: 1-100 мс на создание, много памяти (50-200 МБ)
• Поток: микросекунды на создание, меньше памяти (1-2 МБ)
• Task: еще легче, управляется ThreadPool

Для современной C# разработки предпочитайте Task и async/await вместо явного управления потоками.