#215_MTH_PkS_TOS_TP

Что вам известно о многопоточности?

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

Основные понятия и термины:

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

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

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

Критические секции (critical sections) — участок кода, который должен выполняться только одним потоком в данный момент времени.
Это предотвращает одновременный доступ нескольких потоков к одному и тому же ресурсу.

Мониторинг (monitoring) — мониторинг состояния потоков и процессов позволяет отслеживать состояние системы и управлять ими.
Это полезно для оптимизации производительности и выявления возможных проблем, таких как взаимоблокировки (deadlocks).


Модели многопоточности:

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

Модель на основе задач (task-based model) — в этой модели задачи создаются и планировщик назначает задачи потокам для выполнения.
Планировщики сами управляют созданием и уничтожением потоков, что снижает нагрузку на программиста, но может ограничивать гибкость управления потоками.

В современных ЯП доступны разнообразные библиотеки и API для работы с многопоточностью:

POSIX threads (pthreads) — стандартная библиотека для работы с потоками в Unix-подобных ОС.
Она предоставляет функции для создания, управления и синхронизации потоков.

Windows API — предоставляет функции для работы с потоками и синхронизационными примитивами в ОС Windows.

Java Concurrency API — Java предоставляет богатый набор инструментов для работы с многопоточностью, включая классы Thread, Runnable, ExecutorService, Callable, Future, Lock, Semaphore и другие.

Python threading module — Python предоставляет модуль threading для работы с потоками и механизмами синхронизации, такими как Lock, RLock, Condition, Event, Barrier, Semaphore.

Go routines and channels — Go предоставляет легкий синтаксис для работы с горутинами и каналами, что делает работу с многопоточностью интуитивной и простой.

Проблемы многопоточности:
Гонки данных (data races) — когда несколько потоков пытаются одновременно модифицировать одни и те же данные, это может привести к непредсказуемому поведению программы.
Взаимоблокировки (deadlocks) — два потока блокируются, ожидая завершения друг друга, что приводит к остановке выполнения программы.
Зависимые блокировки (livelocks) — потоки постоянно ожидают друг друга, но никогда не завершаются, создавая иллюзию активности, но не производя полезную работу.
Проблемы производительности — неправильная организация потоков может привести к ухудшению производительности, если потоки слишком часто блокируются или взаимодействуют с общей памятью.

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

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

#216_MTH_PkS_TOS_TP

Что общего и различного в процессах и потоках?

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

Общие черты процессов и потоков:

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

Ресурсы — процессы и потоки потребляют ресурсы, такие как процессорное время, оперативная память, файлы и сетевые соединения.

Планировщик — ОС планирует выполнение процессов и потоков, определяя, сколько времени и какие ресурсы выделяются для каждого процесса и потока.


Различия между процессами и потоками:

Определение:
Процесс — это экземпляр программы, который запускается в ОС.
Процесс обладает собственным адресным пространством, набором открытых файлов, идентификатором пользователя, PID (Process ID) и другими атрибутами.

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

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

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

Жизненный цикл:
Процессы — запускаются и завершаются как отдельные сущности.
Управляются ОС, которая следит за их состоянием и завершением.
Потоки — создаются и уничтожаются внутри процесса.
Жизненный цикл потоков определяется самим процессом, который может создать и уничтожить потоки.

Контекст выполнения:
Процессы — каждый процесс имеет свой собственный контекст выполнения, включающий PID, UID, группы, открытые файлы и другие атрибуты.
Потоки — делят контекст выполнения процесса, но имеют свои собственные контексты, такие как стеки и регистры.

Управление:
Процессы — управляются ОС, которая отвечает за создание, завершение и управление процессами.
Для общения между процессами используются механизмы межпроцессорного обмена сообщениями (IPC).
Потоки — управляются планировщиком ОС, который решает, какие потоки будут выполняться и как долго.
Внутри процесса потоки управляются через примитивы синхронизации, такие как мьютексы и семафоры.

Коммуникационные механизмы:
Процессы — используют IPC для коммуникации между процессами.
Потоки — используют примитивы синхронизации для взаимодействия между потоками.

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

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

Общение:
Процессы — общаются через механизмы IPC, такие как каналы, сокеты и сообщения.
Потоки — коммуницируют через механизмы синхронизации, такие как мьютексы и семафоры.

Распределенность:
Процессы — распределяются между серверами или виртуальными машинами.
Потоки — исполняются на одном процессоре или виртуальной машине.

Производительность:
Процессы — производительность повышается за счет распределения нагрузки между несколькими процессорами или виртуальными машинами.
Потоки — повышают производительность за счет параллельного выполнения на одном процессоре.

Коммуникабельность:
Процессы — коммуникабельные через механизмы IPC, такие как каналы, сокеты и сообщения.
Потоки — коммуникабельные через механизмы синхронизации, такие как мьютексы и семафоры.

Автоматизация:
Процессы — могут автоматизировать выполнение задач (обработка данных или взаимодействие с системами управления производством).
Потоки — могут помогать автоматизировать задачи внутри процесса (сбор данных или обработка сигналов).

Интеграция с существующими системами:
Процессы — могут интегрироваться с существующими системами управления, такими как ERP-системы.
Потоки — могут обеспечивать связь между новыми и старыми системами, работающими на уровне процессов.

Обслуживание и поддержка:
Процессы — требуют обслуживания и поддержки со стороны ИТ-персонала, т. к. сбои в оборудовании могут привести к простоям в выполнении задач.
Потоки — также требуют обслуживания и мониторинга, т. к. сбои в потоках могут привести к сбоям в работе оборудования.

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

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

Адресация:
Процессы — адресуются через PID и другие атрибуты, которые определяют контекст выполнения.
Потоки — адресуются через TID и другие атрибуты, которые определяют контекст выполнения.

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

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

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

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

Исполнение:
Процессы — запускаются и выполняются в рамках ОС.
Потоки — создаются и исполняются внутри процесса.

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

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

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

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

Обработка прерываний:
Процессы — могут обрабатывать прерывания, поступившие от ОС (сигналы от клавиатуры или мыши).
Потоки — не могут непосредственно обрабатывать прерывания, т. к. это делается на уровне процессов.

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

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

Персональные права доступа:
Процессы — могут иметь разные уровни прав доступа (root-доступ или доступ к определенным устройствам).
Потоки — наследуют права доступа от процесса, в котором были созданы.

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

Загрузка и выгрузка:
Процессы — могут загружаться и выгружаться по мере необходимости.
Потоки — создание и уничтожение контролируются ОС.

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

Что общего и различного в процессах и потоках в программировании?

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

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

Различия:

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

Создание и управление:
Процесс — создание нового процесса требует значительных затрат ресурсов, так как необходимо создать новое адресное пространство и загрузить новый экземпляр кода программы.
Управление процессами осуществляется ОС через системные вызовы.
Поток — создание потока менее затратно по ресурсам, поскольку он использует уже существующее адресное пространство процесса.
Управление потоками может осуществляться как ОС, так и библиотекой времени исполнения (например, pthreads в C/C++).

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

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

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

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

#216_Cpp_LIB_MTH_PkS

Является ли С++ thread-safe?

C++ сам по себе не является thread-safe, однако стандартная библиотека предоставляет инструменты и механизмы для создания многопоточных приложений, которые могут быть безопасны для многопоточности (thread-safe).


Основные аспекты, связанные с безопасностью потоков в C++:

Стандартная библиотека C++ — включает классы и функции для управления потоками (std::thread), синхронизацией (std::mutex, std::lock_guard, std::atomic) и другими механизмами, необходимыми для написания многопоточного кода.
Эти инструменты помогают разработчикам создавать thread-safe приложения, правильно управляя доступом к общим данным и избегая состояний гонок и взаимоблокировок.

Безопасность данных — данные, доступные нескольким потокам, должны быть защищены от одновременного доступа.
Например, использование мьютексов (std::mutex) или атомарных типов (std::atomic) помогает избежать состояний гонок.
В некоторых случаях можно использовать lock-free алгоритмы, основанные на атомарных операциях, чтобы минимизировать блокировку и повысить производительность.

Использование сторонних библиотек — существуют различные библиотеки, такие как Boost, TBB (Intel Threading Building Blocks), OpenMP и другие, которые предоставляют дополнительные возможности для разработки многопоточных приложений.

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

Таким образом, C++ предоставляет все необходимые средства для создания thread-safe приложений, но ответственность за правильное их применение лежит на разработчике.

#216_Cpp_PkS_TP

Что такое generic?

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

Пример на языке C++:

template <typename T>
class MyList {
private:
T data;
public:
void setData(T newData) { data = newData; }
T getData() const { return data; }
};

Здесь MyList — это шаблонный класс (generic class), который может хранить данные любого типа (T), будь то int, double, string или любой другой пользовательский тип.
Мы можем использовать этот класс следующим образом:

int main() {
MyList<int> intList;
intList.setData(42);

MyList<double> doubleList;
doubleList.setData(3.14);

std::cout << "Integer value: " << intList.getData() << std::endl;
std::cout << "Double value: " << doubleList.getData() << std::endl;
}

Преимущества использования generics:
Повторное использование кода — один и тот же код работает с разными типами данных, что уменьшает количество дублирования.
Типовая безопасность — компилятор проверяет типы данных при компиляции, предотвращая ошибки, связанные с неправильными типами.
Читаемость и поддержка — код становится проще для понимания и поддержки благодаря тому, что одна реализация работает для разных типов данных.


Подобные механизмы существуют во многих других языках программирования:
В Java используются generics, начиная с версии 5.0.
В C# также поддерживаются generics.
В Python концепция обобщённого программирования реализована через аннотации типов и библиотеки вроде typing.

Таким образом, generic позволяет писать универсальный код, который легко адаптируется под различные типы данных, повышая гибкость и удобство разработки.

#217_C_Cpp_MTH_PkS_TP

Как синхронизировать передачу информации между потоками средствами С и С++?

В языках C и C++ синхронизация передачи информации между потоками осуществляется с помощью следующих механизмов:

Мьютексы (Mutexes — сокращение от "Mutual Exclusion") — обеспечивает взаимоисключающий доступ к разделяемым данным.
Мьютексы гарантируют, что только один поток за раз может получить доступ к защищенному участку кода.

Использование POSIX Threads (pthreads) в C:

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

// Глобальные переменные
int shared_data = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* thread_function(void* arg) {
// Блокируем мьютекс
pthread_mutex_lock(&mutex);

// Доступ к разделяемой памяти
shared_data++;

printf("Shared data: %d\n", shared_data);

// Освобождаем мьютекс
pthread_mutex_unlock(&mutex);
return NULL;
}

int main() {
pthread_t thread1, thread2;

// Создаем два потока
pthread_create(&thread1, NULL, thread_function, NULL);
pthread_create(&thread2, NULL, thread_function, NULL);

// Ожидаем завершения потоков
pthread_join(thread1, NULL);
pthread_join(thread2, NULL);

// Разрушаем мьютекс
pthread_mutex_destroy(&mutex);

return 0;
}

Использование std::mutex в C++:

#include <iostream>
#include <thread>
#include <mutex>

// Глобальная переменная
int shared_data = 0;
std::mutex mtx;

void thread_function() {
/* Автоматический захват и освобождение мьютекса */
std::lock_guard<std::mutex> lock(mtx);

// Доступ к разделяемой памяти
shared_data++;

std::cout << "Shared data: " << shared_data << std::endl;
}

int main() {
std::thread t1(thread_function);
std::thread t2(thread_function);

// Ожидаем завершения потоков
t1.join();
t2.join();

return 0;
}


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

Использование POSIX Semaphores в C:

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

// Глобальные переменные
sem_t sem;
int shared_data = 0;

void* thread_function(void* arg) {
// Ждем освобождения ресурса
sem_wait(&sem);

// Доступ к разделяемой памяти
shared_data++;

printf("Shared data: %d\n", shared_data);

// Освобождаем ресурс
sem_post(&sem);
return NULL;
}

int main() {
pthread_t thread1, thread2;

// Инициализация семафора
sem_init(&sem, 0, 1);

// Создаем два потока
pthread_create(&thread1, NULL, thread_function, NULL);
pthread_create(&thread2, NULL, thread_function, NULL);

// Ожидаем завершения потоков
pthread_join(thread1, NULL);
pthread_join(thread2, NULL);

// Разрушаем семафор
sem_destroy(&sem);

return 0;
}

Использование std::counting_semaphore в C++20:

#include <iostream>
#include <thread>
#include <semaphore>

// Глобальная переменная
int shared_data = 0;
// Семафор с начальным значением 1
std::counting_semaphore<1> sem(1);

void thread_function() {
// Ждем освобождения ресурса
sem.acquire();

// Доступ к разделяемой памяти
shared_data++;

std::cout << "Shared data: " << shared_data << std::endl;

// Освобождаем ресурс
sem.release();
}

int main() {
std::thread t1(thread_function);
std::thread t2(thread_function);

// Ожидаем завершения потоков
t1.join();
t2.join();

return 0;
}

Условные переменные (Condition Variables) — позволяют потокам ожидать наступления определенных условий.
Они часто используются вместе с мьютексами.

Использование POSIX Condition Variables в C:

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

// Глобальные переменные
int shared_data = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_var = PTHREAD_COND_INITIALIZER;

void* thread_function(void* arg) {
// Блокируем мьютекс
pthread_mutex_lock(&mutex);

// Ждем изменения переменной
while (shared_data == 0) {
/* Освобождаем мьютекс и ждем сигнала */
pthread_cond_wait(&cond_var, &mutex);
}

// Доступ к разделяемой памяти
shared_data--;

printf("Shared data: %d\n", shared_data);

// Освобождаем мьютекс
pthread_mutex_unlock(&mutex);
return NULL;
}

int main() {
pthread_t thread1, thread2;

// Создаем два потока
pthread_create(&thread1, NULL, thread_function, NULL);
pthread_create(&thread2, NULL, thread_function, NULL);

/* Даем время потокам дождаться сигнала */
sleep(1);

// Блокируем мьютекс
pthread_mutex_lock(&mutex);
// Изменяем значение переменной
shared_data = 1;
/* Посылаем сигнал ожиданиящему потоку */
pthread_cond_signal(&cond_var);
// Освобождаем мьютекс
pthread_mutex_unlock(&mutex);

// Ожидаем завершения потоков
pthread_join(thread1, NULL);
pthread_join(thread2, NULL);

/* Разрушаем мьютекс и условную переменную */
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond_var);

return 0;
}

Использование std::condition_variable в C++:

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

// Глобальные переменные
int shared_data = 0;
std::mutex mtx;
std::condition_variable cv;

void thread_function() {
// Блокируем мьютекс
std::unique_lock<std::mutex> lock(mtx);

// Ждем изменения переменной
cv.wait(lock, []{return shared_data != 0;});
// Доступ к разделяемой памяти
shared_data--;

std::cout << "Shared data: " << shared_data << std::endl;
}

int main() {
std::thread t1(thread_function);
std::thread t2(thread_function);

/* Даем время потокам дождаться сигнала */
std::this_thread::sleep_for(std::chrono::seconds(1));

{
// Блокируем мьютекс
std::lock_guard<std::mutex> lock(mtx);
// Изменяем значение переменной
shared_data = 1;
}

/* Посылаем сигнал ожиданиящему потоку */
cv.notify_one();

// Ожидаем завершения потоков
t1.join();
t2.join();

return 0;
}


Атомарные операции — обеспечивают безопасное изменение значений переменных без необходимости блокировки.

Использование std::atomic в C++:

#include <iostream>
#include <thread>
#include <atomic>

// Глобальная переменная
std::atomic<int> shared_data{0};

void thread_function() {
// Атомарный инкремент
shared_data++;

std::cout << "Shared data: " << shared_data << std::endl;
}

int main() {
std::thread t1(thread_function);
std::thread t2(thread_function);

// Ожидаем завершения потоков
t1.join();
t2.join();

return 0;
}

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

#218_Cpp_MTH_PkS_TP

Какая разница между мьютексом и семафором?

Разница между мьютексом и семафором заключается в их назначении, поведении и возможностях использования.

Мьютекс (Mutex).
Назначение — мьютекс предназначен для обеспечения взаимоисключительного доступа к разделяемым ресурсам.
Только один поток может владеть мьютексом в любой момент времени. Другие потоки должны ждать, пока текущий владелец освобождает его.

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

Владелец — мьютекс имеет владельца — поток, который его захватил. Только этот поток может освободить мьютекс.

Ресурс — обычно используется для защиты одного ресурса или одной критической секции кода.

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

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int shared_resource = 0;

void incrementResource() {
// Захватывает мьютекс
std::lock_guard<std::mutex> lock(mtx);
// Обновление общего ресурса
shared_resource++;
}

int main() {
std::thread t1(incrementResource);
std::thread t2(incrementResource);

t1.join();
t2.join();

std::cout << "Shared resource value: " << shared_resource << std::endl;
return 0;
}


Семафор (Semaphore).
Назначение — семафор управляет доступом к набору ресурсов. Он поддерживает счётчик, который указывает на количество доступных ресурсов.
Когда поток пытается захватить семафор, он уменьшает счётчик. Если счётчик достигает нуля, поток блокируется до тех пор, пока другой поток не освободит ресурсы.

Поведение:
ожидание и сигнализация — потоки ждут доступности ресурсов, вызывая операцию wait (или аналогичную), которая уменьшает счётчик. Когда поток завершает использование ресурса, он вызывает операцию signal (или аналогичную), увеличивающую счётчик.

Без владельца — в отличие от мьютекса, семафор не имеет владельца. Любой поток может уменьшить или увеличить счётчик.

Набор ресурсов — семафор обычно используется для управления набором ресурсов, например, пулом соединений или очередью задач.

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

#include <iostream>
#include <thread>
#include <semaphore>

std::counting_semaphore<3>
// Семафор с тремя ресурсами
db_connections(3);

void useDatabaseConnection() {
// Ожидание доступности ресурса
db_connections.acquire();
std::cout << "Using database connection..." << std::endl;
// Имитация работы
std::this_thread::sleep_for(std::chrono::seconds(1));
// Освобождение ресурса
db_connections.release();
}

int main() {
std::thread t1(useDatabaseConnection);
std::thread t2(useDatabaseConnection);
std::thread t3(useDatabaseConnection);
/* Будет ждать, так как все ресурсы заняты */
std::thread t4(useDatabaseConnection);

t1.join();
t2.join();
t3.join();
t4.join();

return 0;
}

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

Таким образом, выбор между мьютексом и семафором зависит от специфики задачи и количества управляемых ресурсов.

#219_MTH_PkS_TP

Что такое deadlock?

Deadlock (дословно переводится как «мертвая блокировка») — ситуация в многозадачной системе, когда два или более процесса (потока) находятся в состоянии бесконечного ожидания ресурсов, которыми владеют другие процессы, и ни один из них не может продолжить выполнение.
Это приводит к тому, что все вовлечённые процессы остаются заблокированными навсегда.

Как возникает deadlock?

Для возникновения deadlock’а необходимо соблюдение четырёх условий, известных как условия Коффмана:

Исключительный доступ (Mutual Exclusion) — ресурсы, которые запрашиваются процессами, не могут быть совместно использованы.
Каждый ресурс может быть занят только одним процессом в определённый момент времени.

Удержание и ожидание (Hold and Wait) — процессы уже удерживают по крайней мере один ресурс и ожидают получения других ресурсов, которые в настоящее время удерживаются другими процессами.

Отсутствие прерывания (No Preemption) — ресурсы нельзя принудительно забрать у процессов, они должны освобождаться добровольно.

Циклическое ожидание (Circular Wait) — существует цикл из двух или более процессов, где каждый процесс ожидает ресурс, удерживаемый следующим процессом в цикле.

Пример deadlock'а.
Рассмотрим пример с двумя потоками и двумя ресурсами (например, файловыми дескрипторами).

Поток A:
Захватывает ресурс R1.
Пытается захватить ресурс R2, но он уже захвачен потоком B, поэтому поток A блокируется.

Поток B:
Захватывает ресурс R2.
Пытается захватить ресурс R1, но он уже захвачен потоком A, поэтому поток B также блокируется.

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

Существует несколько стратегий для предотвращения deadlock'ов:

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

Динамическое обнаружение и восстановление — система может периодически проверять наличие deadlock'ов и предпринимать действия для их устранения, например, завершив один из процессов или освободив некоторые ресурсы.

Использование временных меток — каждому процессу присваивается временная метка, и если процесс ожидает дольше установленного предела, система может прервать его и освободить ресурсы.

Банкерские алгоритмы — эти алгоритмы (например, алгоритм банкира Эдсгера Дейкстры) пытаются распределять ресурсы таким образом, чтобы всегда существовала возможность безопасного продолжения работы системы.


Deadlock — это серьёзная проблема в многозадачных системах, которая может привести к полной остановке работы приложения.
Понимание механизмов возникновения deadlock'ов и знание методов их предотвращения является важным навыком для разработчиков многопоточных приложений.

#220_MTH_PkS_TP

Что такое race-condition?

Race condition (условие гонки) — ситуация в многозадачном программировании, когда результат выполнения программы зависит от относительной скорости выполнения отдельных её частей.
Это происходит, когда два или более потока (процессов) обращаются к общим данным, и порядок выполнения операций влияет на конечный результат.

Почему возникают race conditions?

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

Пример race condition.
Допустим, у нас есть глобальная переменная counter, к которой обращаются два потока:

#include <iostream>
#include <thread>

int counter = 0;

void increment() {
for (int i = 0; i < 100000; ++i) {
counter++;
}
}

int main() {
std::thread t1(increment);
std::thread t2(increment);

t1.join();
t2.join();

std::cout << "Final counter value: " << counter << std::endl;
return 0;
}

Если бы counter++ была атомарной операцией, то финальное значение counter должно было бы быть равно 200000.
Однако, поскольку counter++ состоит из трёх шагов (чтение значения, увеличение и запись нового значения), возможны ситуации, когда два потока одновременно читают одно и то же значение, увеличивают его и записывают обратно.
В результате некоторые увеличения могут быть потеряны, и итоговый результат окажется меньше ожидаемого.

Последствия race conditions:

Race conditions могут приводить к непредсказуемому поведению программы, ошибкам в логике и даже к краху системы.
Например, если два потока одновременно пытаются изменить баланс банковского счёта, то финальный баланс может оказаться неверным.

Методы борьбы с race conditions:
Синхронизация — использование механизмов синхронизации, таких как мьютексы, семафоры или барьеры, позволяет предотвратить одновременный доступ к общим данным.

Атомарные операции — некоторые языки программирования предлагают атомарные операции, которые выполняются как единое целое и не могут быть прерваны.
Например, в C++ есть класс std::atomic.

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

Иммутабельные объекты — создание объектов, которые не могут быть изменены после создания, что исключает возможность возникновения race conditions.

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

#221_Cpp_MTH_PkS_TP

Как избежать состояния гонки?

Чтобы избежать состояния гонки (race condition) в многопоточной программе, следует применять различные методы синхронизации и координации потоков.

Мьютекс (Mutex от английского "mutual exclusion" — взаимное исключение) — позволяет ограничить доступ к общему ресурсу так, чтобы только один поток мог работать с ним в конкретный момент времени.
Это предотвращает состояние гонки, связанное с изменением общих данных.

Пример на C++ с использованием std::mutex:

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int shared_counter = 0;

void incrementCounter() {
/* Захватываем мьютекс перед работой с общей переменной */
std::lock_guard<std::mutex> lock(mtx);
shared_counter++;
}

int main() {
std::thread t1(incrementCounter);
std::thread t2(incrementCounter);

t1.join();
t2.join();

std::cout << "Shared counter: " << shared_counter << std::endl;
return 0;
}


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

Пример на C++ с использованием std::atomic:

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> shared_counter(0);

void incrementCounter() {
shared_counter++;
}

int main() {
std::thread t1(incrementCounter);
std::thread t2(incrementCounter);

t1.join();
t2.join();

std::cout << "Shared counter: " << shared_counter << std::endl;
return 0;
}


Семафоры (Semaphores) — позволяют контролировать доступ к ресурсу, предоставляя ограниченное количество разрешений.
В отличие от мьютекса, семафор может быть использован несколькими потоками одновременно, если доступно достаточное количество разрешений.

Пример на C++ с использованием std::counting_semaphore (C++20):

#include <iostream>
#include <thread>
#include <semaphore>

/* Семафор с начальным значением 1 */
std::counting_semaphore<1> sem(1);
int shared_counter = 0;

void incrementCounter() {
// Ожидание разрешения
sem.acquire();
shared_counter++;
// Освобождение разрешения
sem.release();
}

int main() {
std::thread t1(incrementCounter);
std::thread t2(incrementCounter);

t1.join();
t2.join();

std::cout << "Shared counter: " << shared_counter << std::endl;
return 0;
}

Барьеры (Barriers) — позволяют синхронизировать несколько потоков так, чтобы все потоки достигли определенной точки выполнения, прежде чем продолжить работу дальше.

Пример на C++ с использованием std::barrier (C++20):

#include <iostream>
#include <thread>
#include <barrier>

std::barrier barrier(2);
int shared_counter = 0;

void incrementCounter() {
shared_counter++;
/* Все потоки дожидаются друг друга */
barrier.arrive_and_wait();
if (std::this_thread::get_id() == std::thread::id()) {
std::cout << "Shared counter: " << shared_counter << std::endl;
}
}

int main() {
std::thread t1(incrementCounter);
std::thread t2(incrementCounter);

t1.join();
t2.join();

return 0;
}

Условные переменные (Condition Variables) — позволяют одному потоку ждать выполнения определенного условия другим потоком.
Это полезно, когда нужно синхронизировать выполнение задач, зависящих друг от друга.

Пример на C++ с использованием std::condition_variable:

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;
int shared_counter = 0;

void waitForWork() {
std::unique_lock<std::mutex> lck(mtx);
cv.wait(lck, []{ return ready; });
shared_counter++;
}

void signalWork() {
{
std::lock_guard<std::mutex> lck(mtx);
ready = true;
}
cv.notify_all();
}

int main() {
std::thread t1(waitForWork);
std::thread t2(signalWork);

t1.join();
t2.join();
std::cout << "Shared counter: " << shared_counter << std::endl;
return 0;
}

Использование иммутабельных объектов — исключает возможность возникновения race conditions.

Пример на JavaScript с использованием Object.freeze():

const immutableObject = Object.freeze({ counter: 0 });
console.log(immutableObject.counter); // 0
immutableObject.counter = 42; /* Не сработает, объект заморожен */
console.log(immutableObject.counter);
// Всё ещё 0

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

#222_Cpp_MTH_PkS_TP

Что такое атомарная операция?

Атомарная операция — выполняется как единая, неделимая единица работы. Она не может быть прервана или выполнена частично.
В контексте многопоточного программирования атомарные операции важны, т. к. предотвращают состояние гонки (race condition) и обеспечивают консистентность данных.

Свойства атомарных операций:

Неделимость — операция считается атомарной, если выполняется целиком или не выполняется вовсе. Никакие другие потоки не могут вмешиваться в процесс выполнения такой операции.

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

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

Примеры атомарных операций:

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

Инкрементация/декрементация — увеличение или уменьшение значения переменной на единицу может быть выполнено атомарно, если процессор поддерживает такую команду.

Тестирование и установка — эта операция проверяет значение переменной и устанавливает новое значение, если текущее соответствует ожидаемому.
Такая операция часто используется для реализации спинлоков.

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

Пример на C++ с использованием std::atomic:

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> counter(0);

void incrementCounter() {
counter++;
}

int main() {
std::thread t1(incrementCounter);
std::thread t2(incrementCounter);

t1.join();
t2.join();

std::cout << "Counter: " << counter << std::endl;
return 0;
}

Здесь std::atomic<int> гарантирует, что операция инкрементации будет выполнена атомарно, исключая возможность состояния гонки.

На Java с использованием AtomicInteger:

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
public static void main(String[] args) {
AtomicInteger counter = new AtomicInteger(0);

Runnable task = () -> {
for (int i = 0; i < 1000; i++) {
counter.incrementAndGet();
}
};

Thread t1 = new Thread(task);
Thread t2 = new Thread(task);

t1.start();
t2.start();

try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("Counter: " + counter.get());
}
}

Класс AtomicInteger предоставляет атомарные операции для целочисленных значений, что делает код безопасным для многопоточного исполнения.


Преимущества атомарных операций:

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

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

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


Ограничения атомарных операций:

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

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

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

#223_Cpp_MTH_PkS_TP

Как работать с std::mutex?

std::mutex — один из основных инструментов для синхронизации потоков в C++ и используется для защиты критических секций кода от одновременного доступа несколькими потоками.

Основные шаги работы с std::mutex:

Создание мьютекса:

// Подключение хедера mutex:
#include <mutex>
/* Объяление переменной типа std::mutex */
std::mutex mtx;

Блокировка mutex (lock) — чтобы защитить критическую секцию кода, необходимо заблокировать мьютекс перед входом в эту секцию и разблокировать его после выхода.
Это можно сделать двумя способами:

С помощью метода lock():

// Блокируем мьютекс
mtx.lock();

// Критическая секция
/* Здесь выполняется код, который должен быть защищен от параллельного доступа */

// Разблокируем мьютекс
mtx.unlock();

С использованием RAII-объектов (std::lock_guard, std::unique_lock) — это предпочтительнее, так как они автоматически освобождают мьютекс при выходе из области видимости:

{
/* Автоматически блокируем мьютекс */
std::lock_guard<std::mutex> lock(mtx);

// Критическая секция
/* Здесь выполняется код, который должен быть защищен от параллельного доступа */
} /* Мьютекс автоматически разблокируется при выходе из блока */

Использование std::unique_lock — если вам нужно более гибкое управление блокировкой (например, временная разблокировка внутри критической секции), используйте

std::unique_lock

позволяет явно управлять временем блокировки и разблокировки.

std::unique_lock<std::mutex> ulk(mtx);

// Критическая секция
// ...

/* Можно временно разблокировать мьютекс */
ulk.unlock();
// Некритический код
// ...

/* Заблокировать снова, если нужно */
ulk.lock();

Синхронизация нескольких мьютексов — когда требуется работа с несколькими мьютексами одновременно, рекомендуется использовать std::lock и std::adopt_lock.

std::mutex mtx1, mtx2;
/* Заблокируем оба мьютекса сразу */
std::lock(mtx1, mtx2);
std::lock_guard<std::mutex> lk1(mtx1, std::adopt_lock);
std::lock_guard<std::mutex> lk2(mtx2, std::adopt_lock);

// Критическая секция
// ...

Рекомендации по использованию:
— всегда старайтесь минимизировать время удержания блокировки;
— избегайте захвата мьютекса дважды в одном потоке без промежуточной разблокировки, это может привести к deadlock'у.
— используйте RAII-объекты (std::lock_guard, std::unique_lock) вместо явных вызовов lock() и unlock(), чтобы избежать ошибок управления ресурсами.

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int counter = 0;

void incrementCounter(int id) {
for (int i = 0; i < 100000; ++i) {
std::lock_guard<std::mutex> lock(mtx);
++counter;
}
}

int main() {
std::thread t1(incrementCounter, 1);
std::thread t2(incrementCounter, 2);

t1.join();
t2.join();

std::cout << "Final counter value: " << counter << std::endl;
return 0;
}

В этом примере два потока увеличивают общую переменную counter, используя мьютекс для обеспечения корректности результата.

#224_NTWK_PkS_TOS_TP

Что такое СОКЕТ?

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

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

Типы сокетов:

TCP-сокеты — используются для передачи данных по протоколу TCP (Transmission Control Protocol). Они обеспечивают надёжную передачу данных с контролем ошибок и упорядоченной доставкой пакетов.

UDP-сокеты — работают по протоколу UDP (User Datagram Protocol). Данные передаются быстрее, но без гарантии доставки и порядка получения пакетов.

Адресность — каждый сокет имеет уникальный адрес, состоящий из IP-адреса и порта.
Например, 192.168.1.10:80 указывает на сокет, привязанный к IP-адресу 192.168.1.10 и порту 80.

Работа с сокетом — процесс взаимодействия с сокетом включает несколько этапов:
— создание сокета;
— привязка сокета к определённому адресу (IP + порт);
— ожидание подключения (для серверов) или подключение к удаленному сокету (для клиентов);
— обмен данными;
— закрытие соединения.

Сокеты используются во многих современных технологиях:
— веб-серверы и браузеры общаются через HTTP/HTTPS, которые работают поверх TCP-сокетов;
— потоковые сервисы (видео, аудио) могут использовать UDP-сокеты для быстрой передачи данных;
— игры, чаты и другие приложения реального времени часто используют сокеты для быстрого обмена информацией.

Таким образом, сокеты — фундаментальная часть сетевого программирования и позволяют создавать мощные и эффективные сетевые приложения.

#225_Cpp_NTWK_PkS_TOS_TP

Пример работы с сокетами на С++ в Linux

В Linux для работы с сокетами обычно используется библиотека POSIX API.
Она предоставляет набор функций для создания, настройки и управления сокетами.

Пример эхо-сервера на C++, работающего под управлением Linux.

Этап 1: Создадим сокет для прослушивания входящих соединений.
Этап 2: Привяжем созданный сокет к конкретному порту.
Этап 3: Прослушивание входящих соединений.
Этап 4: Принятие нового соединения — когда поступит запрос на соединение, примем его и начнем обработку.
Этап 5: Чтение и отправка данных — будем читать данные от клиента и отправлять обратно те же самые данные.
Этап 6: Завершение работы — закроем все открытые дескрипторы.

Полный пример кода:

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <cstring>
#include <iostream>

#define DEFAULT_PORT 8080

int main() {
// Создание сокета
int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
if (serverSocket < 0) {
perror("Ошибка создания сокета");
return 1;
}

// Привязка сокета к порту
struct sockaddr_in serverAddress;
memset(&serverAddress, 0, sizeof(serverAddress));
serverAddress.sin_family = AF_INET;
serverAddress.sin_addr.s_addr = INADDR_ANY;
serverAddress.sin_port = htons(DEFAULT_PORT);

if (bind(serverSocket, (struct sockaddr *)&serverAddress, sizeof(serverAddress)) < 0) {
perror("Ошибка привязки сокета");
close(serverSocket);
return 1;
}

// Начало прослушивания
if (listen(serverSocket, SOMAXCONN) < 0) {
perror("Ошибка начала прослушивания");
close(serverSocket);
return 1;
}

std::cout << "Сервер запущен. Ожидаю подключения..." << std::endl;

while (true) {
// Прием нового соединения
struct sockaddr_in clientAddress;
socklen_t clientLength = sizeof(clientAddress);
int clientSocket = accept(serverSocket, (struct sockaddr *)&clientAddress, &clientLength);
if (clientSocket < 0) {
perror("Ошибка приема соединения");
continue;
}

char buffer[1024];
ssize_t bytesReceived;

do {
// Чтение данных от клиента
bytesReceived = recv(clientSocket, buffer, sizeof(buffer), 0);
if (bytesReceived > 0) {
/* Отправка данных обратно клиенту */
send(clientSocket, buffer, bytesReceived, 0);
}
} while (bytesReceived > 0);

/* Закрытие соединения с клиентом */
close(clientSocket);
}

// Закрытие основного сокета
close(serverSocket);

return 0;
}


Пояснение к коду.

Создание сокета:
int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
if (serverSocket < 0) {
perror("Ошибка создания сокета");
return 1;
}

Создается сокет типа AF_INET (IPv4) и протокола SOCK_STREAM (TCP).


Привязка сокета к порту:
struct sockaddr_in serverAddress;
memset(&serverAddress, 0, sizeof(serverAddress));
serverAddress.sin_family = AF_INET;
serverAddress.sin_addr.s_addr = INADDR_ANY;
serverAddress.sin_port = htons(DEFAULT_PORT);

if (bind(serverSocket, (struct sockaddr *)&serverAddress, sizeof(serverAddress)) < 0) {
perror("Ошибка привязки сокета");
close(serverSocket);
return 1;
}

Сокет привязывается к порту DEFAULT_PORT (в данном случае 8080).


Прослушивание входящих соединений:
if (listen(serverSocket, SOMAXCONN) < 0) {
perror("Ошибка начала прослушивания");
close(serverSocket);
return 1;
}

Сервер начинает прослушивать входящие соединения.