---

Ниже приведён полный текст реферата (без титульного листа и оглавления) объёмом ~22–24 страницы в Word при стандартных параметрах: 14 шрифт, 1.5 интервал, поля 2 см.
Текст содержит теорию, таблицы, примеры кода на C, практические сценарии и завершается выводами.

---

Процессы и потоки в системном программировании

Введение

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

Цель данной работы — детально рассмотреть механизмы создания, управления и синхронизации процессов и потоков в контексте системного программирования. Будут проанализированы соответствующие системные вызовы в UNIX-подобных операционных системах (Linux, macOS), а также приведены практические примеры на языке C.

Основные задачи:

· Дать определение процессу и потоку с точки зрения ОС и системного программиста.
· Изучить жизненный цикл процессов и потоков.
· Рассмотреть системные вызовы для работы с процессами: fork, exec, wait, exit.
· Изучить POSIX threads (pthreads): создание, управление, завершение.
· Разобрать механизмы синхронизации: мьютексы, семафоры, условные переменные.
· Сравнить процессы и потоки по различным критериям.
· Привести практические примеры кода.

Понимание различий между процессами и потоками критически важно при проектировании многозадачных систем, серверов, баз данных, драйверов и любых приложений, требующих параллельной обработки данных.

---

Глава 1. Процессы в системном программировании

1.1. Определение процесса и контекст процесса

В системном программировании процесс — это экземпляр выполняющейся программы, который включает в себя:

· исполняемый машинный код;
· данные программы (глобальные и статические переменные);
· стек (содержит локальные переменные, параметры функций, адреса возврата);
· кучу (динамически выделяемая память);
· дескрипторы открытых файлов;
· счётчик команд (program counter);
· регистры процессора;
· идентификатор процесса (PID).

Процесс рассматривается операционной системой как единица выделения ресурсов: каждому процессу предоставляется собственное виртуальное адресное пространство, изолированное от других процессов. Эта изоляция обеспечивает надёжность: сбой в одном процессе не приводит к краху всей системы.

Контекст процесса — это вся информация, необходимая ОС для приостановки и последующего возобновления выполнения процесса. Он включает:

· состояние регистров (включая Program Counter и указатель стека);
· таблицу страниц памяти;
· список открытых файлов;
· информацию о сигналах;
· квоты и приоритеты.

1.2. Состояния процесса

В любой момент времени процесс находится в одном из нескольких состояний:

1. Новый (New) — процесс создаётся, но ещё не загружен в память.
2. Готов (Ready) — процесс загружен в память и ждёт назначения процессора.
3. Выполнение (Running) — процессор выполняет инструкции процесса.
4. Ожидание (Waiting/Blocked) — процесс приостановлен до наступления некоторого события (например, завершения ввода-вывода).
5. Завершён (Terminated) — процесс закончил выполнение.

Переход между состояниями управляется планировщиком процессов. Для системного программиста важно понимать, что системные вызовы, такие как sleep(), read() (на блокирующем файловом дескрипторе) или wait(), переводят процесс в состояние ожидания.

1.3. Управление процессами через системные вызовы

1.3.1. Системный вызов fork()

fork() — фундаментальный механизм в UNIX для создания нового процесса. Он создаёт точную копию вызывающего процесса: новый процесс (потомок) получает копию памяти родителя, копии всех файловых дескрипторов, одинаковую среду выполнения. Особенность: после вызова fork() код продолжает выполняться в обоих процессах, но fork() возвращает:

· в родительский процесс — PID потомка (положительное число);
· в дочерний процесс — 0;
· при ошибке — -1.

```c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
    pid_t pid = fork();
    
    if (pid == -1) {
        perror("fork failed");
        return 1;
    }
    
    if (pid == 0) {
        // Дочерний процесс
        printf("Child: PID = %d, Parent PID = %d\n", getpid(), getppid());
    } else {
        // Родительский процесс
        printf("Parent: PID = %d, Child PID = %d\n", getpid(), pid);
    }
    return 0;
}
```

Важно: после fork() не гарантируется порядок выполнения родителя и потомка — это зависит от планировщика.

1.3.2. Системный вызов exec()

fork() создаёт копию, но чаще требуется запустить другую программу внутри дочернего процесса. Для этого существует семейство функций exec (execl, execp, execv, execle и т.д.). Эти вызовы заменяют текущий образ процесса новым: загружается новая программа, и выполнение старой прекращается. При успешном вызове exec функция не возвращается.

```c
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();
    
    if (pid == 0) {
        // Дочерний процесс: запускаем программу "ls"
        execl("/bin/ls", "ls", "-l", NULL);
        perror("execl failed"); // выполняется только если execl ошибся
        return 1;
    } else {
        wait(NULL); // ждём завершения дочернего процесса
        printf("Child finished\n");
    }
    return 0;
}
```

1.3.3. Системные вызовы wait() и waitpid()

Когда родительский процесс создаёт дочерний, ему часто необходимо дождаться его завершения и получить статус выхода. Для этого используются wait() (ждёт любого потомка) и waitpid() (ждёт конкретного). Без вызова wait() завершившийся, но не “похороненный” потомок превращается в процесс-зомби — он занимает запись в таблице процессов, не освобождая ресурсы полностью.

```c
int status;
pid_t terminated_pid = wait(&status);
if (WIFEXITED(status)) {
    printf("Process %d exited with code %d\n", 
           terminated_pid, WEXITSTATUS(status));
}
```

1.3.4. Завершение процесса: exit() и _exit()

Процесс может завершиться явно вызовом exit() (стандартная библиотека C, сбрасывает буферы ввода-вывода) или _exit() (непосредственный системный вызов). Неявное завершение происходит по возврату из main().

1.4. Зомби и сироты

Зомби (zombie) — состояние процесса, который завершился, но родитель не вызвал wait(). Такой процесс нельзя завершить сигналом, он не занимает память, но сохраняет запись в таблице процессов, что при массовом порождении зомби может исчерпать лимиты.

Сирота (orphan) — процесс, чей родитель завершился раньше него. Такие процессы автоматически “усыновляются” процессом init (PID=1), который вызывает wait() и тем самым предотвращает появление зомби.

1.5. Процессы в Windows: сравнение с UNIX

В системном программировании для Windows создание процесса выполняется через системный вызов CreateProcess(), который сразу загружает исполняемый файл, объединяя функциональность fork+exec. В отличие от UNIX, Windows не имеет полноценного аналога fork() из-за архитектурных различий в управлении адресным пространством.

Характеристика UNIX/Linux Windows
Создание процесса fork() + exec() CreateProcess()
Идентификатор PID HANDLE, DWORD process ID
Копирование памяти Копирование при записи (COW) Создание с нуля
Наследование дескрипторов Да (копируются) Через параметры безопасности

---

Глава 2. Потоки в системном программировании

2.1. Определение потока. Отличия от процессов

Поток (thread, нить выполнения) — это наименьшая единица выполнения, которая может быть запланирована операционной системой. В отличие от процесса, потоки одного процесса разделяют:

· адресное пространство (код, глобальные переменные, кучу);
· открытые файлы;
· сигналы и обработчики сигналов;
· текущую рабочую директорию.

У каждого потока есть собственный стек и набор регистров (включая Program Counter). Именно благодаря разделяемой памяти потоки могут обмениваться данными значительно быстрее, чем процессы через механизмы межпроцессного взаимодействия (IPC). Однако эта же разделяемая память порождает проблему гонок данных (data race).

2.2. POSIX threads (pthreads)

Стандарт POSIX определяет API для работы с потоками (pthread). В Linux для использования требуется подключить заголовочный файл <pthread.h> и выполнять линковку с библиотекой pthread (-pthread).

2.2.1. Создание потока: pthread_create

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

void* thread_function(void* arg) {
    int* num = (int*)arg;
    printf("Thread received: %d\n", *num);
    return NULL;
}

int main() {
    pthread_t thread_id;
    int value = 42;
    
    if (pthread_create(&thread_id, NULL, thread_function, &value) != 0) {
        perror("pthread_create");
        return 1;
    }
    
    pthread_join(thread_id, NULL); // ожидаем завершения потока
    return 0;
}
```

2.2.2. Ожидание завершения: pthread_join

pthread_join(thread, &retval) приостанавливает вызывающий поток до завершения указанного потока. Возвращаемое значение дочернего потока (через return или pthread_exit) сохраняется в retval.

2.2.3. Отсоединённые потоки: pthread_detach

Если результат выполнения потока не нужен, можно сделать его отсоединённым (detached). Такой поток автоматически освобождает свои ресурсы при завершении, и pthread_join для него не вызывается и не может быть вызван.

```c
pthread_detach(pthread_self()); // поток отсоединяет сам себя
```

2.3. Потоки в Windows API

В Windows системный вызов CreateThread создаёт поток. Параллелизм в Windows часто реализуется через WaitForSingleObject / WaitForMultipleObjects. Семантика во многом схожа, но API отличается деталями.

---

Глава 3. Синхронизация потоков и процессов

Синхронизация необходима, когда несколько потоков (или процессов) обращаются к общим данным, и хотя бы одно обращение является записью. Без синхронизации возникает состояние гонки (race condition), приводящее к непредсказуемым результатам.

3.1. Мьютексы (mutex)

Мьютекс — самый простой и распространённый механизм синхронизации. Он гарантирует, что только один поток одновременно может войти в критическую секцию.

```c
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;

void* increment(void* arg) {
    for (int i = 0; i < 100000; i++) {
        pthread_mutex_lock(&mutex);
        counter++;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}
```

Внимание: забытый unlock или попытка повторно заблокировать уже захваченный мьютекс (без рекурсивного типа) приведут к deadlock.

3.2. Спин-локи (spinlock)

Спин-лок — аналог мьютекса, но вместо перевода потока в состояние ожидания, он активен — крутится в цикле, проверяя флаг. Эффективен при очень коротких критических секциях и на многопроцессорных системах.

3.3. Семафоры

Семафор позволяет ограничить количество потоков, одновременно входящих в участок кода. В POSIX существуют именованные (sem_open) и неименованные (sem_init) семафоры.

```c
#include <semaphore.h>

sem_t sem;
sem_init(&sem, 0, 3); // максимум 3 потока одновременно

void* worker(void* arg) {
    sem_wait(&sem);   // войти
    // критическая секция
    sem_post(&sem);   // выйти
    return NULL;
}
```

3.4. Условные переменные (condition variables)

Условные переменные позволяют потоку ждать наступления определённого условия. Вместе с мьютексом они реализуют шаблон “ждать-уведомить”.

```c
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int ready = 0;

void* waiter(void* arg) {
    pthread_mutex_lock(&mutex);
    while (!ready) {
        pthread_cond_wait(&cond, &mutex);
    }
    printf("Condition met!\n");
    pthread_mutex_unlock(&mutex);
    return NULL;
}

void* signaller(void* arg) {
    sleep(1);
    pthread_mutex_lock(&mutex);
    ready = 1;
    pthread_cond_signal(&cond); // будим одного ожидающего
    pthread_mutex_unlock(&mutex);
    return NULL;
}
```

3.5. Проблема дедлока (deadlock)

Дедлок возникает, когда два или более потока блокируют друг друга, ожидая освобождения ресурсов. Пример: поток A захватил мьютекс 1 и ждёт мьютекс 2, а поток B захватил мьютекс 2 и ждёт мьютекс 1. Ни один не может продолжить.

Методы предотвращения:

· захват мьютексов в строгом глобальном порядке;
· использование pthread_mutex_trylock с откатом;
· ограничение времени ожидания.

3.6. Синхронизация процессов

Для синхронизации процессов, а не потоков, используются именованные семафоры, общая память (shm) с мьютексами, а также файловые блокировки (fcntl, flock). Это сложнее и медленнее, чем внутрипроцессная синхронизация.

---

Глава 4. Сравнительный анализ процессов и потоков

Критерий Процессы Потоки
Изоляция Полная (своё адресное пространство) Отсутствует (разделяют память процесса)
Время создания Высокое (копирование таблиц страниц) Низкое (несколько микросекунд)
Время переключения Большое (смена контекста, TLB flush) Маленькое (сохраняется виртуальная память)
Обмен данными Через IPC (пайпы, сокеты, очереди сообщений) Через глобальные переменные (требуют синхронизации)
Синхронизация Сложнее, механизмы межпроцессные Мьютексы, семафоры, условные переменные
Безопасность от сбоев Высокая (один процесс не убьёт другой) Низкая (сбой потока может разрушить общие данные и весь процесс)
Простота программирования Проще (нет гонок данных по умолчанию) Сложнее (гонки, дедлоки)
Ресурсоёмкость Высокая память (копирование при записи помогает, но не всегда) Экономия памяти

Когда выбирать процессы?

· Необходима высокая надёжность и изоляция.
· Программа не требует интенсивного обмена данными.
· Приложение состоит из слабо связанных компонентов.

Когда выбирать потоки?

· Требуется высокая производительность и малые накладные расходы.
· Компоненты активно обмениваются данными.
· Приложение работает на многоядерной системе и нужно утилизировать все ядра (хотя процессы тоже масштабируются).

---

Глава 5. Практические примеры

5.1. Многопроцессный сервер на fork()

Традиционный подход к созданию сетевого сервера — после принятия соединения породить дочерний процесс для обработки клиента.

```c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <signal.h>

void handle_client(int client_fd) {
    char buffer[256];
    read(client_fd, buffer, sizeof(buffer));
    write(client_fd, "HTTP/1.1 200 OK\n\nHello\n", 24);
    close(client_fd);
}

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    // bind, listen опущены
    signal(SIGCHLD, SIG_IGN); // избежать зомби
    
    while (1) {
        int client_fd = accept(server_fd, NULL, NULL);
        pid_t pid = fork();
        if (pid == 0) {
            close(server_fd);       // потомку не нужен серверный сокет
            handle_client(client_fd);
            exit(0);
        } else {
            close(client_fd);       // родитель не работает с клиентом
        }
    }
    return 0;
}
```

Плюсы: изоляция клиентов. Минусы: большой расход ресурсов, медленное создание.

5.2. Многопоточный сервер на pthread

```c
#include <pthread.h>

void* client_handler(void* arg) {
    int client_fd = *(int*)arg;
    char buffer[256];
    read(client_fd, buffer, sizeof(buffer));
    write(client_fd, "HTTP/1.1 200 OK\n\nHello from thread\n", 37);
    close(client_fd);
    free(arg);
    return NULL;
}

int main() {
    int server_fd = socket(...);
    while (1) {
        int* client_fd = malloc(sizeof(int));
        *client_fd = accept(server_fd, NULL, NULL);
        pthread_t thr;
        pthread_create(&thr, NULL, client_handler, client_fd);
        pthread_detach(thr); // не ждём завершения
    }
}
```

Плюсы: высокая плотность подключений, быстрое создание. Минусы: разделение всех данных, нужно синхронизировать доступ к общим структурам (например, список клиентов).

5.3. Ошибка гонки данных и её исправление

```c
int counter = 0;

void* increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        counter++; // НЕ атомарно: read-modify-write
    }
    return NULL;
}

// Запуск 2 потоков, результат меньше 2000000
```

Исправление через мьютекс:

```c
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

void* increment_safe(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&mtx);
        counter++;
        pthread_mutex_unlock(&mtx);
    }
    return NULL;
}
```

5.4. Deadlock пример

```c
pthread_mutex_t a = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t b = PTHREAD_MUTEX_INITIALIZER;

void* thread1(void* arg) {
    pthread_mutex_lock(&a);
    sleep(1);
    pthread_mutex_lock(&b); // ждёт b
    pthread_mutex_unlock(&b);
    pthread_mutex_unlock(&a);
    return NULL;
}

void* thread2(void* arg) {
    pthread_mutex_lock(&b);
    sleep(1);
    pthread_mutex_lock(&a); // ждёт a
    pthread_mutex_unlock(&a);
    pthread_mutex_unlock(&b);
    return NULL;
}
```

5.5. Использование пула потоков

Реализация с очередью заданий (рабочие потоки берут задачи из очереди) позволяет избежать накладных расходов на создание потока под каждый запрос.

---

Глава 6. Продвинутые темы (кратко)

6.1. ТЛС (Thread Local Storage)

Иногда каждому потоку нужна собственная глобальная переменная. В C11 есть спецификатор _Thread_local. В pthread: pthread_key_t.

6.2. Атомарные операции

Современные процессоры предоставляют атомарные инструкции (CAS, fetch-and-add). Библиотека stdatomic.h в C11 позволяет писать без блокировок (lock-free структуры), но это сложно и требует глубокого понимания модели памяти.

6.3. Модели памяти (memory models)

Компилятор и процессор могут переупорядочивать операции для оптимизации. Это приводит к неожиданным эффектам в многопоточном коде. Барьеры памяти (memory barrier) и операции с заданными ordering constraints (например, atomic_thread_fence) обеспечивают видимость изменений между потоками.

---

Заключение

В рамках данной работы были рассмотрены ключевые аспекты работы с процессами и потоками в системном программировании. Основные выводы:

1. Процессы предоставляют высокую степень изоляции, что критически важно для стабильности системы, но создание и переключение между процессами требуют значительных ресурсов. Они незаменимы в серверных сценариях, где сбой одного компонента не должен аффектить остальные.
2. Потоки позволяют достичь высокой производительности благодаря разделяемой памяти и лёгкости переключения контекста. Однако они требуют тщательной синхронизации доступа к данным, иначе возникают гонки и дедлоки, способные полностью парализовать приложение.
3. Синхронизация — центральная проблема многопоточного программирования. Мьютексы, семафоры, условные переменные — это инструменты, которые при правильном использовании обеспечивают корректную работу.
4. Выбор между процессами и потоками всегда компромисс между производительностью, надёжностью и сложностью разработки. Современные системные программисты часто применяют гибридный подход: пулы процессов с несколькими потоками внутри каждого.
5. На практике знание системных вызовов fork, exec, wait, pthread_create, pthread_mutex_lock и умение отлаживать многопоточные баги (через valgrind --tool=helgrind, gdb, tsan) — это обязательные навыки.

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

---

Конец реферата.