Принципы работы в UNIX-подобных ОС на примере Linux. Многозадачное программирование в Linux

Оригинал: Light-Weight Processes: Dissecting Linux Threads
Авторы: Vishal Kanaujia, Chetan Giridhar
Дата публикации: 1 Августа 2011 г.
Перевод: А.Панин
Дата публикации перевода: 22 октября 2012 г.

В этой статье, предназначенной для разработчиков Linux и студентов факультетов компьютерных наук, рассматриваются основы работы программных потоков и их реализация на основе легковесных процессов в ОС Linux, а для лучшего понимания приводятся примеры исходного кода.

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

Программные потоки имеют свои идентификаторы (thread ID) и могут выполняться независимо друг от друга. Они делят между собой одно адресное пространство процесса и используют эту особенность в качестве преимущества, позволяющего не использовать каналы IPC (систем межпроцессного взаимодействия - разделяемой памяти, каналов и других систем) для обмена данными. Программные потоки процесса могут взаимодействовать - например, независимые потоки могут получать/изменять значение глобальной переменной. Эта модель взаимодействия исключает лишние затраты ресурсов на вызовы IPC на уровне ядра. Поскольку потоки работают в едином адресном пространстве, переключения контекста для потока быстры и не ресурсоемки.

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

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

Несколько любопытных особенностей

Наиболее известной особенностью работы с потоками является их синхронизация, особенно при наличии разделяемого ресурса, отмеченного как критический сегмент. Это сегмент кода, в котором осуществляется доступ к разделяемому ресурсу и который не должен быть доступен более чем одному потоку в любой момент времени. Поскольку каждый поток может исполняться независимо, доступ к разделяемому ресурсу не контролируется, что приводит к необходимости использования примитивов синхронизации, включающих в себя мьютексы (mutual exclusion - взаимное исключение), семафоры, блокировки чтения/записи и другие.

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

Как программные потоки реализованы в Linux?

Linux позволяет разрабатывать и использовать многопоточные приложения. На пользовательском уровне реализация потоков в Linux соответствует открытому стандарту POSIX (Portable Operating System Interface for uniX - Переносимый интерфейс операционных систем Unix), обозначенному как IEEE 1003. Библиотека пользовательского уровня (glibc.so в Ubuntu) предоставляет реализацию API POSIX для потоков.

В Linux программные потоки существуют в двух отдельных пространствах - пространстве пользователя и пространстве ядра. В пространстве пользователя потоки создаются при помощи POSIX-совместимого API библиотеки pthread . Эти потоки пространства пользователя неразрывно связаны с потоками пространства ядра. В Linux потоки пространства ядра воспринимаются как "легковесные процессы". Легковесный процесс является единицей основной среды исполнения. В отличие от различных вариантов UNIX, включая такие системы, как HP-UX и SunOS, в Linux не существует отдельной системы для работы с потоками. Процесс или поток в Linux рассматривается как "задача" (task) и использует одинаковые внутренние структуры (ряд структур struct task_structs ).

Для ряда потоков процесса, созданных в пространстве пользователя, в ядре существует ряд связанных с ними легковесных процессов. Пример иллюстрирует это утверждение: #include #include #include Int main() { pthread_t tid = pthread_self(); int sid = syscall(SYS_gettid); printf("LWP id is %dn", sid); printf("POSIX thread id is %dn", tid); return 0; }

При помощи утилиты ps можно получить информацию о процессах, а также о легковесных процессах/потоках этих процессов: kanaujia@ubuntu:~/Desktop$ ps -fL UID PID PPID LWP C NLWP STIME TTY TIME CMD kanaujia 17281 5191 17281 0 1 Jun11 pts/2 00:00:02 bash kanaujia 22838 17281 22838 0 1 08:47 pts/2 00:00:00 ps -fL kanaujia 17647 14111 17647 0 2 00:06 pts/0 00:00:00 vi clone.s

Что такое легковесные процессы?

Легковесным процессом является процесс, поддерживающий работу потока пространства пользователя. Каждый поток пространства пользователя неразрывно связан с легковесным процессом. Процедура создания легковесного процесса отличается от процедуры создания обычного процесса; у пользовательского процесса "P" может существовать ряд связанных легковесных процессов с одинаковым идентификатором группы (group ID). Группировка позволяет ядру производить разделение ресурсов (ресурсы включают в себя адресное пространство, страницы физической памяти (VM), обработчики сигналов и дескрипторы файлов). Это также позволяет ядру избежать переключений контекста при работе с этими процессами. Исчерпывающее разделение ресурсов является причиной наименования этих процессов легковесными.

Как Linux создает легковесные процессы?

В Linux создание легковесных процессов осуществляется при помощи нестандартизированного системного вызова clone() . Он похож на вызов fork() , но с более широкими возможностями. Вообще, вызов fork() реализуется при помощи вызова clone() с дополнительными параметрами, указывающими на ресурсы, которые будут разделены между процессами. Вызов clone() создает процесс, при этом дочерний процесс разделяет с родительским элементы среды исполнения, включая память, дескрипторы файлов и обработчики сигналов. Библиотека pthread также использует вызов clone() для реализации потоков. Обратитесь к файлу исходного кода ./nptl/sysdeps/pthread/createthread.c в директории исходных кодов glibc версии 2.11.2.

Создание своего легковесного процесса

Продемонстрируем пример использования вызова clone() . Посмотрите на исходный код из файла demo.c , приведенный ниже:

#include #include #include #include #include #include #include //стек размером 64kB #define STACK 1024*64 // Дочерний поток выполнит эту функцию int threadFunction(void* argument) { printf("child thread entering\n"); close((int*)argument); printf("child thread exiting\n"); return 0; } int main() { void* stack; pid_t pid; int fd; fd = open("/dev/null", O_RDWR); if (fd < 0) { perror("/dev/null"); exit(1); } // Резервирование памяти для стека stack = malloc(STACK); if (stack == 0) { perror("malloc: could not allocate stack"); exit(1); } printf("Creating child thread\n"); // Вызов clone() для создания дочернего потока pid = clone(&threadFunction, (char*) stack + STACK, SIGCHLD | CLONE_FS | CLONE_FILES |\ CLONE_SIGHAND | CLONE_VM, (void*)fd); if (pid == -1) { perror("clone"); exit(2); } // Ожидание завершения дочернего потока pid = waitpid(pid, 0, 0); if (pid == -1) { perror("waitpid"); exit(3); } // Попытка записи в файл закончится неудачей, так как поток // закрыл файл if (write(fd, "c", 1) < 0) { printf("Parent:\t child closed our file descriptor\n"); } // Освободить память, используемую для стека free(stack); return 0; }

Программа demo.c позволяет создавать потоки по своей сути тем же способом, что и библиотека pthread . Тем не менее, прямое использование вызова clone() нежелательно, поскольку в случае неправильного использования разрабатываемое приложение может завершиться с ошибкой. Синтаксис функции clone() в Linux представлен ниже: #include int clone (int (*fn) (void *), void *child_stack, int flags, void *arg);

Первым аргументом является функция потока; она вызывается во время запуска потока. После того, как вызов clone() успешно завершается, функция fn начинает исполняться одновременно с вызывающим процессом.

Следующим аргументом является указатель на участок памяти для стека дочернего процесса. За шаг до вызова fork() и clone() от программиста требуются действия по резервированию памяти и передаче указателя для использования ее в качестве стека дочернего процесса, так как родительский и дочерний процесс делят между собой страницы памяти - они включают в себя и стек. Дочерний процесс может вызвать функцию, отличную от родительского процесса, поэтому и требуется отдельный стек. В нашей программе мы резервируем этот участок памяти в куче при помощи функции malloc() . Размер стека был установлен равным 64 Кб. Так как стек на архитектуре x86 растет вниз, необходимо симулировать аналогичное поведение, используя выделенную память с конца участка. По этой причине мы передаем следующий адрес функции clone() : (char*) stack + STACK

Следующий аргумент flags особо важен. Он позволяет указать, какие ресурсы необходимо разделять с созданным процессом. Мы выбрали битовую маску SIGCHLD | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_VM , описанную ниже:

SIGCHLD : поток отправляет сигнал SIGCHLD родительскому процессу после завершения. Установка этого параметра позволяет родительскому процессу использовать функцию wait() для ожидания завершения всех потоков.
CLONE_FS : Разделять информацию о файловых системах между родительским процессом и потоком. Информация включает в себя корень файловой системы, рабочую директорию и значение umask.
CLONE_FILES : Разделять таблицу файловых дескрипторов между родительским процессом и потоком. Изменения в таблице отображаются в родительском процессе и всех потоках.
CLOSE_SIGHAND : Разделять таблицу обработчиков сигналов между родительским процессом и потомком. И снова, если родительский процесс или один из потоков изменит обработчик сигнала, изменение будет отображено на таблицах других процессов.
CLONE_VM : Родительский процесс и потоки работают в одном пространстве памяти. Все записи в память или отображения, сделанные одним из них, доступны другим процессам.

Последним параметром является аргумент, передаваемый функции (threadFunction ), в нашем случае это файловый дескриптор.

Пожалуйста, обратитесь к примеру работы с легковесными процессами demo.c , опубликованному нами ранее.

Поток закрывает файл (/dev/null ), открытый родительским процессом. Поскольку родительский процесс и поток делят таблицу файловых дескрипторов, операция закрытия файла затрагивает и родительский процесс, что приводит к неудаче при последующем вызове write() . Родительский процесс ожидает завершения работы потока (момента приема сигнала SIGCHLD ). После этого он освобождает зарезервированную память и возвращает управление.

Скомпилируйте и запустите программу обычным образом; вывод должен быть аналогичен приведенному ниже: $gcc demo.c $./a.out Creating child thread child thread entering child thread exiting Parent: child closed our file descriptor $

Linux предоставляет поддержку эффективной, простой и масштабируемой инфраструктуры для работы с потоками. Это стимулирует интерес программистов к экспериментам и разработке библиотек для работы с потоками, использующих clone() в качестве основной функции.

Наберите в своей оболочке следующую команду:

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

На экран будут выведен список всех работающих в системе процессов. Если хотите посчитать количество процессов, наберите что-нибудь, наподобие этого:

$ ps -e --no-headers | nl | tail -n 1

74 4650 pts/0 00:00:00 tail

Первое число - это количество работающих в системе процессов. Пользователи KDE могут воспользоваться программой kpm, а пользователи Gnome - программой gnome-system-monitor для получения информации о процессах. На то он и Linux, чтобы позволять пользователю делать одно и то же разными способами.

Возникает вопрос: «Что такое процесс?». Процессы в Linux, как и файлы, являются аксиоматическими понятиями. Иногда процесс отождествляют с запущенной программой, однако, это не всегда так. Будем считать, что процесс - это рабочая единица системы, которая выполняет что-то. Многозадачность - это возможность одновременного сосуществования нескольких процессов в одной системе.

Linux - многозадачная операционная система. Это означает, что процессы в ней работают одновременно. Естественно, это условная формулировка. Ядро Linux постоянно переключает процессы, то есть время от времени дает каждому из них сколько-нибудь процессорного времени. Переключение происходит довольно быстро, поэтому нам кажется, что процессы работают одновременно.

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

К каждому процессу в системе привязана пара целых неотрицательных чисел: идентификатор процесса PID (Process IDentifier) и идентификатор родительского процесса PPID (Parent Process IDentifier). Для каждого процесса PID является уникальным (в конкретный момент времени), а PPID равен идентификатору процесса-родителя. Если ввести в оболочку команду ps -ef, то на экран будет выведен список процессов со значениями их PID и PPID (вторая и третья колонки соотв.). Пример работы такой команды:

UID PID PPID C STIME TTY TIME CMD

root 1 0 0 17:08? 00:00:00 /sbin/init

root 2 0 0 17:08? 00:00:00

root 3 2 0 17:08? 00:00:00

root 4 2 0 17:08? 00:00:00

root 5 2 0 17:08? 00:00:00

root 6 2 0 17:08? 00:00:00

root 7 2 0 17:08? 00:00:00

root 8 2 0 17:08? 00:00:00

root 9 2 0 17:08? 00:00:00

root 10 2 0 17:08? 00:00:00

root 11 2 0 17:08? 00:00:00

root 12 2 0 17:08? 00:00:00

root 13 2 0 17:08? 00:00:00

root 14 2 0 17:08? 00:00:00

root 15 2 0 17:08? 00:00:00

root 16 2 0 17:08? 00:00:00

root 17 2 0 17:08? 00:00:00

root 18 2 0 17:08? 00:00:00

root 19 2 0 17:08? 00:00:00

df00 16389 16387 0 20:10 pts/1 00:00:00 /bin/bash

df00 17446 2538 0 20:26? 00:00:00

df00 18544 2932 0 20:41 pts/2 00:00:00 /bin/bash -l

df00 19010 18544 0 20:48 pts/2 00:00:00 ps -ef

Надо отметить, что процесс init всегда имеет идентификатор 1 и PPID равный 0. Хотя в реальности процесса с идентификатором 0 не существует. Дерево процессов можно также представить в наглядном виде при помощи опции --forest программы ps:

2? 00:00:00 kthreadd

3 ?00:00:00 \_ migration/0

4 ?00:00:00 \_ ksoftirqd/0

5 ?00:00:00 \_ watchdog/0

6 ?00:00:00 \_ migration/1

7 ?00:00:00 \_ ksoftirqd/1

8 ?00:00:00 \_ watchdog/1

9 ?00:00:00 \_ events/0

10 ?00:00:00 \_ events/1

11 ?00:00:00 \_ cpuset

12 ?00:00:00 \_ khelper

13 ?00:00:00 \_ netns

14 ?00:00:00 \_ async/mgr

15 ?00:00:00 \_ kintegrityd/0

16 ?00:00:00 \_ kintegrityd/1

18544 pts/2 00:00:00 \_ bash

16388 ?00:00:00 \_ gnome-pty-helpe

16389 pts/1 00:00:00 \_ bash

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

Использование getpid() и getppid()

Процесс может узнать свой идентификатор (PID), а также родительский идентификатор (PPID) при помощи системных вызовов getpid() и getppid().

Системные вызовы getpid() и getppid() имеют следующие прототипы:

pid_t getpid (void);

pid_t getppid (void);

Для использования getpid() и getppid() в программу должны быть включены директивой #include заголовочные файлы unistd.h и sys/types.h (для типа pid_t). Вызов getpid() возвращает идентификатор текущего процесса (PID), а getppid() возвращает идентификатор родителя (PPID). pid_t - это целый тип, размерность которого зависит от конкретной системы. Значениями этого типа можно оперировать как обычными целыми числами типа int.

Рассмотрим теперь простую программу, которая выводит на экран PID и PPID, а затем «замирает» до тех пор, пока пользователь не нажмет .

#include

pid_t pid, ppid;

pid = getpid ();

ppid = getppid ();

printf («PID: %d\n», pid);

printf («PPID: %d\n», ppid);

fprintf (stderr, «Press to exit...»);

Проверим теперь, как работает эта программа. Для этого откомпилируем и запустим ее:

$ gcc -o getpid getpid.c

Press to exit...

Теперь, не нажимая , откроем другое терминальное окно и проверим, правильность работы системных вызовов getpid() иgetppid():

$ ps -ef | grep getpid

df00 19724 19702 0 20:58 pts/3 00:00:00 ./main

df00 19856 18544 0 21:00 pts/2 00:00:00 grep --colour=auto main

ЛАБОРАТОРНАЯ РАБОТА №3

МНОГОЗАДАЧНОЕ ПРОГРАММИРОВАНИЕ В LINUX

1. Цель работы: Ознакомиться с компилятором gcc, методикой отладки программ, функциями работы с процессами.

2. Краткие теоретические сведения.

Минимальным набором ключей компилятора gcc являются - Wall (выводить все ошибки и предупреждения) и - o (output file):

gcc - Wall - o print_pid print_pid. c

Команда создаст исполняемый файл print_pid.

Стандартная библиотека C (libc, реализованная в Linux в glibc), использует возможности многозадачности Unix System V (далее SysV). В libc тип pid_t определен как целое, способное вместить в себе pid. Функция, которая сообщает pid текущего процесса, имеет прототип pid_t getpid (void) и определена вместе с pid_t в unistd. h и sys/types. h).

Для создания нового процесса используется функция fork:

pid_t fork(void)

Вставляя задержку случайной длины при помощи функций sleep и rand, можно нагляднее увидеть эффект многозадачности:

это заставит программу "заснуть" на случайное число секунд: от 0 до 3.

Чтобы в качестве дочернего процесса вызвать функцию, достаточно вызвать ее после ветвления:

// если выполняется дочерний процесс, то вызовем функцию

pid=process(arg);

// выход из процесса

Часто в качестве дочернего процесса необходимо запускать другую программу. Для этого применяется функции семейства exec:

// если выполняется дочерний процесс, то вызов программы

if (execl("./file","file",arg, NULL)<0) {

printf("ERROR while start process\n");

else printf("process started (pid=%d)\n", pid);

// выход из процесса

Часто родительскому процессу необходимо обмениваться информацией с дочерними или хотя бы синхронизироваться с ними, чтобы выполнять операции в нужное время. Один из способов синхронизации процессов - функции wait и waitpid:

#include

pid_t wait(int *status) - приостанавливает выполнение текущего процесса до завершения какого-либо из его процессов-потомков.

pid_t waitpid (pid_t pid, int *status, int options) - приостанавливает выполнение текущего процесса до завершения заданного процесса или проверяет завершение заданного процесса.

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

status=waitpid(pid,&status, WNOHANG);

if (pid == status) {

printf("PID: %d, Result = %d\n", pid, WEXITSTATUS(status)); }

Для изменения приоритетов порожденных процессов используются функции setpriority и. Приоритеты задаются в диапазоне от -20 (высший) до 20 (низший), нормальное значение - 0. Заметим, что повысить приоритет выше нормального может только суперпользователь!

#include

int process(int i) {

setpriority(PRIO_PROCESS, getpid(),i);

printf("Process %d ThreadID: %d working with priority %d\n",i, getpid(),getpriority(PRIO_PROCESS, getpid()));

return(getpriority(PRIO_PROCESS, getpid()));

Для уничтожения процесса служит функция kill:

#include

int kill(pid_t pid, int sig);

Если pid > 0, то он задает PID процесса, которому посылается сигнал. Если pid = 0, то сигнал посылается всем процессам той группы, к которой принадлежит текущий процесс.

sig - тип сигнала. Некоторые типы сигналов в Linux:

SIGKILL Этот сигнал приводит к немедленному завершению процесса. Этот сигнал процесс не может игнорировать.

SIGTERM Этот сигнал является запросом на завершение процесса.

SIGCHLD Система посылает этот сигнал процессу при завершении одного из его дочерних процессов. Пример:

if (pid[i] == status) {

printf("ThreadID: %d finished with status %d\n", pid[i], WEXITSTATUS(status));

else kill(pid[i],SIGKILL);

3. Методические указания.

3.1. Для ознакомления с опциями компилятора gcc, описанием функций языка С используйте инструкции man и info.

3.2. Для отладки программ удобно использовать встроенный редактор файлового менеджера Midnight Commander (MC), выделяющий цветом различные языковые конструкции и указывающий в верхней строке экрана положение курсора в файле (строка, столбец).

3.3. В файловом менеджере Midnight Commander имеется буфер команд, вызываемый сочетанием клавиш - H, перемещение по которому производится стрелками управления курсором (вверх и вниз). Для вставки команды из буфера в командную строку используется клавиша , для редактирования команды из буфера - клавиши <- и ->, и .

3.4. Помните, что текущая директория не содержится в path, поэтому из командной строки необходимо запускать программу как "./print_pid". В MC достаточно навести курсор на файл и нажать .

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

3.6. Для протоколирования результатов выполнения программ целесообразно использовать перенаправление вывода с консоли в файл: ./test > result. txt

3.7. Для доступа к файлам, созданным на сервере Linux, применяйте протокол ftp, клиентская программа которого имеется в Windows 2000 и встроена в файловый менеджер FAR. При этом учетная запись и пароль те же, что и при подключении по протоколу ssh.

4.1. Ознакомиться с опциями компилятора gcc, методикой отладки программ.

4.2. Для вариантов заданий из лабораторной работы №1 написать и отладить программу, реализующую порожденный процесс.

4.3. Для вариантов заданий из лабораторной работы №1 написать и отладить программу, реализующую родительский процесс, вызывающий и отслеживающий состояние порожденных процессов - программ (ждущий их завершения или уничтожающий их, в зависимости от варианта).

4.4. Для вариантов заданий из лабораторной работы №1 написать и отладить программу, реализующую родительский процесс, вызывающий и отслеживающий состояние порожденных процессов - функций (ждущий их завершения или уничтожающий их, в зависимости от варианта).

5. Варианты заданий. См. варианты заданий из лабораторной работы №1

6. Содержание отчета.

6.1. Цель работы.

6.2. Вариант задания.

6.3. Листинги программ.

6.4. Протоколы выполнения программ.

7. Контрольные вопросы.

7.1. Особенности компиляции и запуска С-программ в Linux.

7.2. Что такое pid, как его определить в операционной системе и программе?

7.3. Функция fork - назначение, применение, возвращаемое значение.

7.4. Как запустить на выполнение в порожденном процессе функцию? Программу?

7.5. Способы синхронизации родительского и дочерних процессов.

7.6. Как узнать состояние порожденного процесса при его завершении и возвращенное им значение?

7.7. Как управлять приоритетами процессов?

7.8. Как уничтожить процесс в операционной системе и программе?

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

В семействах ОС Windows — каждая программа запускает один процесс выполнения, в котором находится как минимум один поток (нить). В процессе может находиться множество потоков, между которыми делится процессорное время. Один процесс не может напрямую обратиться к памяти другого процесса, а потоки же разделяют одно адресное пространство одного процесса. То есть в Windows — процесс это совокупность потоков.

В Linux же немного по-другому. Сущность процесса такая же, как и в Windows — это исполняемая программа со своими данными. Но вот поток в Linux является отдельным процессом (можно встретить название как «легковесный процесс», LWP). Различие такое же — процесс отдельная программа со своей памятью, не может напрямую обратиться к памяти другого процесса, а вот поток, хоть и отдельный процесс, имеет доступ к памяти процесса-родителя . LWP процессы создаются с помощью системного вызова clone() с указанием определенных флагов.

Но также имеется такая вещь, которая называется «POSIX Threads» — библиотечка стандарта POSIX, которая организует потоки (они же нити) внутри процесса. Т.е тут уже распараллеливание происходит в рамках одного процесса.

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

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

Я рассмотрю два варианта «распараллеливания» программы — создания потока/нити с помощью функций из pthread.h (POSIX Threads), либо создание отдельного процесса с помощью функции fork().

Сегодня рассмотрим потоки из библиотеки pthread.

Шаблон кода для работы с потоками выглядит следующим образом:

#include //потоковая функция void* threadFunc(void* thread_data){ //завершаем поток pthread_exit(0); } int main(){ //какие то данные для потока (для примера) void* thread_data = NULL; //создаем идентификатор потока pthread_t thread; //создаем поток по идентификатору thread и функции потока threadFunc //и передаем потоку указатель на данные thread_data pthread_create(&thread, NULL, threadFunc, thread_data); //ждем завершения потока pthread_join(thread, NULL); return 0; }

#include

//потоковая функция

//завершаем поток

pthread_exit (0 ) ;

int main () {

//какие то данные для потока (для примера)

void * thread_data = NULL ;

//создаем идентификатор потока

pthread_t thread ;

//создаем поток по идентификатору thread и функции потока threadFunc

//и передаем потоку указатель на данные thread_data

pthread_create (& thread , NULL , threadFunc , thread_data ) ;

//ждем завершения потока

pthread_join (thread , NULL ) ;

return 0 ;

Как видно из кода, сущность потока воплощена в функции, в данном случае, threadFunc. Имя такой функции может быть произвольным, а вот возвращаемый тип и тип входного аргумента должны быть строго void*. Данная функция будет выполняться в отдельном потоке исполнения, поэтому необходимо с особой осторожностью подходить к реализации данной функции из-за доступа к одной и той же памяти родительского процесса многими потоками. Завершение достигается несколькими вариантами: поток достиг точки завершения (return, pthread_exit(0)), либо поток был завершен извне.

Создание потока происходит с помощью функции pthread_create(pthread_t *tid, const pthread_attr_t *attr, void*(*function)(void*), void* arg), где: tid — идентификатор потока, attr — параметры потока (NULL — атрибуты по умолчанию, подробности в man), function — указатель на потоковую функцию, в нашем случае threadFunc и arg — указатель на передаваемые данные в поток.

Функция pthread_join ожидает завершения потока thread. Второй параметр этой функции — результат, возвращаемый потоком.

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

#include #include #include #include //размеры матриц #define N 5 #define M 5 //специальная структура для данных потока typedef struct{ int rowN; //номер обрабатываемой строки int rowSize; //размер строки //указатели на матрицы int** array1; int** array2; int** resArr; } pthrData; void* threadFunc(void* thread_data){ //получаем структуру с данными pthrData *data = (pthrData*) thread_data; //складываем элементы строк матриц и сохраняем результат for(int i = 0; i < data->rowSize; i++) data->resArr[i] = data->array1[i] + data->array2[i]; return NULL; } int main(){ //выделяем память под двумерные массивы int** matrix1 = (int**) malloc(N * sizeof(int*)); int** matrix2 = (int**) malloc(N * sizeof(int*)); int** resultMatrix = (int**) malloc(N * sizeof(int*)); //выделяем память под элементы матриц for(int i = 0; i < M; i++){ matrix1[i] = (int*) malloc(M * sizeof(int)); matrix2[i] = (int*) malloc(M * sizeof(int)); resultMatrix[i] = (int*) malloc(M * sizeof(int)); } //инициализируем начальными значениями for(int i = 0; i < N; i++){ for(int j = 0; j < M; j++){ matrix1[i][j] = i; matrix2[i][j] = j; resultMatrix[i][j] = 0; } } //выделяем память под массив идентификаторов потоков pthread_t* threads = (pthread_t*) malloc(N * sizeof(pthread_t)); //сколько потоков - столько и структур с потоковых данных pthrData* threadData = (pthrData*) malloc(N * sizeof(pthrData)); //инициализируем структуры потоков for(int i = 0; i < N; i++){ threadData[i].rowN = i; threadData[i].rowSize = M; threadData[i].array1 = matrix1; threadData[i].array2 = matrix2; threadData[i].resArr = resultMatrix; //запускаем поток pthread_create(&(threads[i]), NULL, threadFunc, &threadData[i]); } //ожидаем выполнение всех потоков for(int i = 0; i < N; i++) pthread_join(threads[i], NULL); //освобождаем память free(threads); free(threadData); for(int i = 0; i < N; i++){ free(matrix1[i]); free(matrix2[i]); free(resultMatrix[i]); } free(matrix1); free(matrix2); free(resultMatrix); return 0; }

#include

//размеры матриц

#define N 5

#define M 5

//специальная структура для данных потока

typedef struct {

int rowN ; //номер обрабатываемой строки

int rowSize ; //размер строки

//указатели на матрицы

int * * array1 ;

int * * array2 ;

int * * resArr ;

} pthrData ;

void * threadFunc (void * thread_data ) {

//получаем структуру с данными

pthrData * data = (pthrData * ) thread_data ;

//складываем элементы строк матриц и сохраняем результат

for (int i = 0 ; i < data -> rowSize ; i ++ )

data -> resArr [ data -> rowN ] [ i ] = data -> array1 [ data -> rowN ] [ i ] + data -> array2 [ data -> rowN ] [ i ] ;

return NULL ;

int main () {

//выделяем память под двумерные массивы

int * * matrix1 = (int * * ) malloc (N * sizeof (int * ) ) ;

int * * matrix2 = (int * * ) malloc (N * sizeof (int * ) ) ;

int * * resultMatrix = (int * * ) malloc (N * sizeof (int * ) ) ;

//выделяем память под элементы матриц

for (int i = 0 ; i < M ; i ++ ) {

matrix1 [ i ] = (int * ) malloc (M * sizeof (int ) ) ;

matrix2 [ i ] = (int * ) malloc (M * sizeof (int ) ) ;

resultMatrix [ i ] = (int * ) malloc (M * sizeof (int ) ) ;

//инициализируем начальными значениями

for (int i = 0 ; i < N ; i ++ ) {

for (int j = 0 ; j < M ; j ++ ) {

matrix1 [ i ] [ j ] = i ;

matrix2 [ i ] [ j ] = j ;

resultMatrix [ i ] [ j ] = 0 ;

//выделяем память под массив идентификаторов потоков

pthread_t * threads = (pthread_t * ) malloc (N * sizeof (pthread_t ) ) ;

//сколько потоков - столько и структур с потоковых данных

pthrData * threadData = (pthrData * ) malloc (N * sizeof (pthrData ) ) ;

//инициализируем структуры потоков

for (int i = 0 ; i < N ; i ++ ) {

threadData [ i ] . rowN = i ;