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

Разница между процессом и потоком (тредом) в Unix-подобных системах

В Unix-подобных системах процесс и поток (thread) — это фундаментальные концепции многозадачности, но они существенно различаются по своей архитектуре и поведению.

Процесс (Process)

Процесс — это экземпляр выполняющейся программы со своим собственным изолированным адресным пространством, ресурсами и контекстом выполнения. Каждый процесс в Unix создаётся вызовом fork() (или его вариациями) и обладает:

• Изолированным виртуальным адресным пространством — память одного процесса недоступна другому без специальных механизмов (разделяемая память, pipe, socket).
• Отдельными дескрипторами файлов, таблицей сигналов и окружением.
• Независимым состоянием — завершение одного процесса не затрагивает другие (если не учитывать родительско-дочерние связи).
• Собственным идентификатором PID.

#include <unistd.h>
#include <stdio.h>

int main() {
    pid_t pid = fork(); // Создание нового процесса
    
    if (pid == 0) {
        // Дочерний процесс
        printf("Child PID: %d\n", getpid());
    } else {
        // Родительский процесс
        printf("Parent PID: %d, child PID: %d\n", getpid(), pid);
    }
    
    return 0;
}

Поток (Thread)

Поток (часто называемый "тредом") — это легковесная единица выполнения внутри процесса, разделяющая с другими потоками этого же процесса адресное пространство и большую часть ресурсов. В Unix-подобных системах потоки реализуются через POSIX Threads (pthreads):

• Разделяют адресное пространство процесса — все потоки одного процесса видят одну и ту же память, что упрощает обмен данными, но требует синхронизации.
• Имеют собственный стек и регистры, но разделяют кучу (heap), статические данные и дескрипторы файлов.
• Используют общий PID, но имеют уникальные идентификаторы потоков (TID).
• Более легковесны — создание и переключение между потоками дешевле, чем между процессами.

#include <pthread.h>
#include <stdio.h>

void* thread_func(void* arg) {
    printf("Thread ID: %lu\n", pthread_self());
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_func, NULL); // Создание потока
    pthread_join(thread, NULL); // Ожидание завершения потока
    return 0;
}

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

Практические следствия для разработчика на Go

Хотя Go использует собственную модель горутин (goroutines), понимание низкоуровневых потоков важно:

1. Планировщик Go (scheduler) мультиплексирует горутины на ограниченное количество потоков ОС (обычно равное количеству ядер).
2. Системные вызовы блокируют поток ОС, но не обязательно всю программу — планировщик может переключиться на другую горутину в этом же потоке.
3. При использовании CGO или взаимодействии с нативными библиотеками важно учитывать различия между потоками и процессами.

// Пример: горутины в Go не соответствуют 1:1 потокам ОС
package main

import (
    "fmt"
    "runtime"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            fmt.Printf("Goroutine %d, OS threads: %d\n", 
                id, runtime.GOMAXPROCS(0))
        }(i)
    }
    wg.Wait()
}

Заключение

Процессы обеспечивают максимальную изоляцию и безопасность, но за счёт накладных расходов на коммуникацию. Потоки предлагают высокопроизводительный параллелизм с общим состоянием, но требуют тщательной синхронизации. В современных Unix-системах оба подхода часто комбинируются: процессы обеспечивают отказоустойчивость и безопасность, а потоки внутри них — эффективный параллелизм. Для Go-разработчика понимание этих различий важно при оптимизации производительности, отладке конкурентных проблем и интеграции с системными компонентами.