Linux количество потоков приложения

Обновлено: 07.07.2024

Зачем нам нужно вводить потоки после того, как у нас есть концепция процессов? Каковы преимущества использования многопоточности? В какой системе следует использовать многопоточность? Сначала мы должны ответить на эти вопросы.

Одной из причин использования многопоточности является то, что это очень "экономная" многозадачная операция по сравнению с процессами. . Мы знаем, что в системе Linux запуск нового процесса должен быть назначен его независимому адресному пространству и создано большое количество таблиц данных для поддержки сегмента кода, сегмента стека и сегмента данных. Это своего рода «дорогостоящая» многозадачность. Способ работы. Однако несколько потоков, запущенных в процессе, используют одно и то же адресное пространство друг с другом и совместно используют большую часть данных. Пространство, затрачиваемое на запуск потока, намного меньше места, затрачиваемого на запуск процесса, и потоки переключаются между собой. Требуемое время намного меньше, чем время, необходимое для переключения между процессами. Согласно статистике, в целом стоимость процесса примерно в 30 раз превышает стоимость потока.Конечно, эти данные могут сильно отличаться в конкретной системе.
Вторая причина использования многопоточности - удобный механизм связи между потоками. . Для разных процессов у них есть независимые пространства данных, и передача данных может осуществляться только через коммуникацию.Этот метод не только трудоемкий, но и очень неудобен. Это не относится к потокам. Поскольку пространство данных совместно используется потоками в одном процессе, данные одного потока могут напрямую использоваться другими потоками, что не только быстро, но и удобно. Конечно, совместное использование данных порождает и другие проблемы. Некоторые переменные не могут быть изменены двумя потоками одновременно. Данные, объявленные как статические в некоторых подпрограммах, с большей вероятностью могут нанести катастрофический ущерб многопоточным программам. Это самый важный момент при написании многопоточных программ.

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

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

Один, идентификация потока

У потока есть идентификатор, но он не единственный в системе, а единственный действительный в среде процесса;
Дескриптор потока имеет тип pthread_t, Этот тип нельзя рассматривать как целое число, а как структуру 。

Ниже описаны две функции:

Заголовочный файл: <pthread.h>
опытный образец:int pthread_equal(pthread_t tid1, pthread_t tid2);
Возвращаемое значение: равенство возвращает ненулевое значение, неравенство возвращает ноль.
Описание :: Сравните, равны ли два идентификатора потока.

Заголовочный файл: <pthread.h>
Прототип: pthread_t pthread_self ();
Возвращаемое значение: возвращает идентификатор вызывающего потока.

Два, создание потока

Создайте поток во время выполнения, вы можете выделить работу, которую он должен выполнить для потока (функция выполнения потока), поток разделяет ресурсы процесса. Функция для создания потока: pthread_create ()

Метод компиляции многопоточной программы под linux:

Поскольку библиотека pthread не является библиотекой системы Linux, ее необходимо добавить при компиляции -lpthread

Пример: Давайте посмотрим на следующий пример. В этом примере программа создает поток и печатает идентификатор процесса, идентификатор нового потока и идентификатор потока начального потока.

Скомпилируйте и запустите:

Как мы и ожидали, идентификатор процесса тот же 10310, а идентификатор потока другой. Если основной поток не спит, он может выйти до выполнения нового потока. Следующее является результатом повторного выполнения после удаления. Очевидно, что новый поток не имеет возможности запуститься во время первого выполнения:

Три, завершение потока

Если какой-либо поток процесса вызывает функцию exit, _exit или _Exit, то весь процесс завершается. Обратите внимание, что здесь завершается весь процесс. Одиночный поток может выйти тремя способами, здесь это только выход из потока без завершения всего процесса.

Поток может просто вернуться из процесса запуска, а возвращаемое значение - это код выхода потока.
Поток может быть отменен другими потоками в том же процессе.
Поток вызывает pthread_exit.
Функция pthread_exit:
Прототип: void pthread_exit (void * rval_ptr);
Заголовочный файл: <pthread.h>
Параметры:rval_ptr - это нетипизированный указатель, который указывает на переменную хранения возвращаемого значения потока.
Функция pthread_join:
Прототип: int pthread_join (поток pthread_t, void ** rval_ptr);
Заголовочный файл: <pthread.h>
Возвращаемое значение: в случае успеха возвращает 0, в противном случае возвращает номер ошибки.
параметр:
thread: идентификатор потока.
rval_ptr: Указатель на возвращаемое значение (возвращаемое значение также является указателем) .
Описание:
Вызывающий поток будет блокироваться до тех пор, пока указанный поток не вызовет pthread_exit, не вернется из процедуры запуска или не будет отменен.
Если поток возвращается из своей процедуры запуска, rval_ptr содержит код возврата .
Если поток отменяется, блок памяти, указанный в rval_ptr, устанавливается в: PTHREAD_CANCELED.
Если вас не волнует возвращаемое значение, вы можете установить rval_ptr в NULL.

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

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

Я обнаружил что-то странное в процессе набора кода void *ret ; Непосредственно применять указатель void для хранения данных, хотя указатель на память, на которую указывает указатель void, отсутствует, но сам указатель void имеет адрес , Второй параметр pthread_join имеет тип "void **", поэтому назначьте адрес tret второму параметру, и можно будет найти окончательный результат выполнения программы. Код возврата помещается прямо в адресное пространство, где находится tret . Есть небольшая проблема, о которой нужно знать, Память, используемая параметрами указателя void, используемыми в функциях pthread_create и pthread_exit, должна оставаться действительной после того, как вызывающий объект завершит вызов. , Итак, чтобы решить эту проблему, вы можете использовать глобальную структуру или использовать функцию malloc для выделения структуры. В книге также приведен пример, эксперимент:

Память, используемая параметрами указателя void, используемыми в функциях pthread_create () и pthread_exit * (), должна оставаться действительной после того, как вызывающий объект завершит вызов.

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

Функция очистки вызывается, когда поток выполняет следующие действия, параметр вызова - arg, а последовательность вызова функции очистки организована с помощью pthread_cleanup_push.

ps (processes status — статус процессов) — это встроенная утилита Unix/Linux для просмотра информации, касающейся выбора запущенных процессов в системе: она считывает эту информацию из виртуальных файлов в файловой системе /proc. Это одна из важных утилит для системного администрирования, особенно в рамках мониторинга процессов, чтобы помочь вам понять, что происходит в системе Linux.

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

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

Управление процессами в Linux

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

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

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

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

Программа для показа процессов в Linux

Самый простой способ использовать ps — запустить её без параметров:

ps покажет список процессов в данном терминале.

В выводе присутствует четыре столбца:

PID: идентификационный номер процесса.
TTY: имя консоли, на которой пользователь выполнил вход.
TIME: количество времени центрального процессора, которое потребил процесс.
CMD: имя команды, которая запустила процесс

Как увидеть все процессы в Linux

Добавление опции -e (выбрать все процессы) сделает так, что ps перечислит процессы, которые были запущены всеми пользователями, а не только пользователем, который запускает команду ps. Поскольку это будет длинный список, то вы можете добавить команду less.

Список процессов с возможностью прокрутки в команде less:

Теперь записей о процессах намного больше, но мы видим те же четыре столбца, что и раньше. Вопросительный знак (?) в столбце TTY означает, что процесс запускался не из окна терминала.

Отображение иерархии процессов (дерево процессов в Linux)

Если вы видите, какие процессы запустили другие процессы, то иногда это может помочь выяснить проблему или определить конкретный процесс. Для этого мы используем опцию -H.

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

Чтобы добавить немного ясности, мы можем попросить ps добавить несколько линий ASCII и нарисовать иерархию в виде дерева. Это можно сделать опцией --forest.

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

Как напечатать дерево определённого процесса

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

Об опции -C будет рассказано далее в этой статье.

Фильтрация вывода ps по определённым строкам (по имени команды, например)

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

Больше столбцов в выводе ps

Чтобы добавить дополнительные столбцы к выводу, используйте параметр -f (полный формат).

Дополнительный набор столбцов включён в вывод ps.

Добавлены следующие новые столбцы:

UID: идентификатор пользователя владельца этого процесса.
PPID: идентификатор родительского процесса.
C: Количество детей, которые есть у процесса.
STIME: Время начала. Время, когда процесс был запущен.

Используя опцию -F (дополнительный полный формат), мы можем получить ещё больше столбцов:

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

Теперь добавились следующие столбцы:

SZ: размер страниц ОЗУ образа процесса.
RSS: резидентный размер набора. Это не подкачанная физическая память, используемая процессом.
PSR: процессор, которому назначен процесс.

Нужно ли указывать дефис перед опциями ps

В некоторых примерах вы можете увидеть использование ps с опциями без дефиса или с длинными вариантами написания опций в стиле GNU. Для совместимости, ps поддерживает все три формата. Опции без дефиса — это стиль BSD и значение опций с дефисом и без может быть различным!

Пример показа процессов в формате BSD:

В этой команде значение опций следующее:

u — ориентированный на пользователя формат
a — убирает ограничение «только свои процессы»
x — убирает ограничение «только процессы с терминалом»

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

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

Поиск процессов по идентификатору процесса

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

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

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

Опция -C КОМАНДА позволяет вам искать процесс, используя имя команды. То есть имя команды, которая запустила процесс. Это несколько отличается от строки команды, которая может включать имена путей и параметры или опции.

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

Процессов может быть несколько если запущено множество экземпляров данной команды:

Как увидеть потоки процесса

Чтобы вывести все потоки процесса, используйте флаг -H. Опция -L приведёт к показу столбца LWP (light weight process — процесс с малым весом), а также столбца NLWP (number of light weight process — число процессов с малым весом).

Как увидеть процессы определённого пользователя

Чтобы увидеть процессы, принадлежащие конкретному пользователю, используйте опцию -u СПИСОК ПОЛЬЗОВАТЕЛЕЙ:

Отображаются процессы, принадлежащие учётной записи пользователя mial.

Как вывести все процессы запущенные пользователем root

Это частный случай показа процессов определённого пользователя.

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

Просмотр групповых процессов

Если вы хотите перечислить все процессы, принадлежащие определённой группе (реальный идентификатор группы (RGID) или имя), введите:

Чтобы вывести список всех процессов, принадлежащих эффективному имени группы (или сеанса), введите.

Листинг процессов по терминалам

Чтобы увидеть процессы, связанные с TTY, используйте опцию -t УКАЖИТЕ TTY. При использовании без номера TTY опция -t сообщает о процессах, связанных с текущим окном терминала.

Все перечисленные процессы связаны с pts/1.

Выбор столбцов для отображения

С опцией -o ФОРМАТ вы можете выбрать, какие столбцы вы хотите включить в вывод ps. Столбцы нужно указывать по имени. В руководстве по ps:

вы найдёте длинный список имён столбцов в разделе STANDARD FORMAT SPECIFIERS.

В следующем примере мы выводим потребление процессом времени центрального процессора (pcpu), потребление процессором памяти (pmem) и запустившая его команда вместе с опциями (args):

Обратите внимание, что опция -o не добавляет столбцы в стандартным, а выводит только запрошенные поля.

Сортировка вывода по столбцам

Вы можете отсортировать вывод, используя опцию --sort. Давайте отсортируем вывод по столбцу CPU:

Дефис «-» означает сортировку от большего к меньшему.

Чтобы увидеть десять самых ресурсоемких процессов, передайте вывод через команду head:

Мы получаем отсортированный, усечённый список.

Если мы добавим больше столбцов для вывода, мы сможем отсортировать по большему количеству столбцов.

Без дефиса или со знаком «+» сортировка выполняется от меньшего к большему.

Добавим в сортировку столбец pmem:

Сортировка по-прежнему выполняется по значению pcpu, но если для каких-то записей эти значения одинаковые, то выполняется сортировка по pmem для этих значений.

Давайте сделаем вывод результатов немного более полезным и добавим столбец идентификатора процесса (pid), чтобы мы могли видеть номер процесса каждого процесса в нашем листинге.

Теперь мы можем идентифицировать процессы.

Все возможные поля ps

Чтобы увидеть все возможные для вывода поля ps выполните такую команду:

Эти поля вы можете применять с опцией -o.

Примеры настраиваемого вывода ps

Команда ниже позволяет вам увидеть PID, PPID, имя пользователя и команду процесса.

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

Как найти имя процесса по PID

Чтобы найти имя процесса, используя его PID.

Показать родительский и дочерний процессы

Чтобы выбрать конкретный процесс по его имени, используйте флаг -C, это также отобразит все его дочерние процессы.

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

Как выключить процесс по идентификатору процесса

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

Так или иначе, мы можем определить процессы, которые работают. Зная их идентификатор процесса, мы можем (если нужно) остановить любой из этих процессов с помощью команды kill. Если бы мы хотели убить процесс 898, мы бы использовали этот формат:

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

Как выключить процесс зная его имя

Команда pkill позволяет вам убивать процессы по имени. Убедитесь, что вы определили правильный процесс! Эта команда завершит процесс top.

Как остановить несколько процессов по имени

Если у вас запущено несколько копий процесса, или процесс породил несколько дочерних процессов (как это может сделать Google Chrome), как вы можете выключить их? Это так же просто. Мы используем команду killall.

У нас запущено два экземпляра top:

Мы можем завершить их обоих с помощью этой команды:

Отсутствие ответа означает отсутствие проблем, т. е. оба эти процессы были остановлены.

Прежде чем убить процесс

Убедитесь, что это тот, который вам нужен, и убедитесь, что это не вызовет никаких проблем. В частности, стоит проверить с помощью параметров -H и --forest, чтобы убедиться, что в нем нет важных дочерних процессов, о которых вы забыли.

Устранение неполадок производительности системы Linux

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

Чтобы найти все процессы, потребляющие больше всего памяти и ЦПУ в Linux:

Вывод информации о безопасности

Показать контекст безопасности (специально для SELinux) можно следующим образом:

С помощью этой команды вы также можете отобразить информацию о безопасности в определённом пользователем формате:

Выполните мониторинг процессов в режиме реального времени с помощью утилиты watch

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

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

В этой статье мы познакомимся с POSIX Threads для того, чтобы затем узнать как это все работает в Linux. Не заходя в дебри синхронизации и сигналов, рассмотрим основные элементы Pthreads. Итак, под капотом потоки.

Общие сведения

Множественные нити исполнения в одном процессе называют потоками и это базовая единица загрузки ЦПУ, состоящая из идентификатора потока, счетчика, регистров и стека. Потоки внутри одного процесса делят секции кода, данных, а также различные ресурсы: описатели открытых файлов, учетные данные процесса сигналы, значения umask , nice , таймеры и прочее.

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

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

Таблицы страниц до и после изменения общей страницы памяти во время копирования при записи.

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

Закон Амдаля для распараллеливания процессов.

Используя уравнение, показанное на рисунке, можно вычислить максимальное улучшение производительности системы, использующей N процессоров и фактор F, который указывает, какая часть системы не может быть распараллелена. Например 75% кода запускается параллельно, а 25% — последовательно. В таком случае на двухядерном процессоре будет достигнуто 1.6 кратное ускорение программы, на четырехядерном процессоре — 2.28571 кратное, а предельное значение ускорения при N стремящемся к бесконечности равно 4.

Отображение потоков в режим ядра

Практически все современные ОС — включая Windows, Linux, Mac OS X, и Solaris — поддерживают управление потоками в режиме ядра. Однако потоки могут быть созданы не только в режиме ядра, но и в режиме пользователя. При использовании этого уровня ядро не знает о существовании потоков — все управление потоками реализуется приложением с помощью специальных библиотек. Пользовательские потоки по разному отображаются на потоки в режиме ядра. Всего существует три модели, из которых 1:1 является наиболее часто используемой.

Отображение N:1

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

Отображение 1:1

Это самая проста модель, в которой каждый поток созданный в каком-нибудь процессе непосредственно управляется планировщиком ядра ОС и отображается на один единственный поток в режиме ядра. Чтобы приложение не плодило бесконтрольно потоки, перегружая ОС, вводят ограничение на максимальное количество потоков поддерживаемых в ОС. Данный способ отображения потоков поддерживают ОС Linux и Windows.

Отображение M:N

При таком подходе M пользовательских потоков мультиплексируются в такое же или меньшее N количество потоков ядра. Преодолеваются негативные эффекты двух других моделей: нити по-настоящему исполняются параллельно и нет необходимости в ОС вводить ограничения на их общее количество. Вместе с тем данную модель довольно трудно реализовать с точки зрения программирования.

Потоки POSIX

В конце 1980-х и начале 1990-х было несколько разных API, но в 1995 г. POSIX.1c стандартизовал потоки POSIX, позже это стало частью спецификаций SUSv3. В наше время многоядерные процессоры проникли даже в настольные ПК и смартфоны, так что у большинства машин есть низкоуровневая аппаратная поддержка, позволяющая им одновременно выполнять несколько потоков. В былые времена одновременное исполнение потоков на одноядерных ЦПУ было лишь впечатляюще изобретательной, но очень эффективной иллюзией.

Pthreads определяет набор типов и функций на Си.

pthread_t — идентификатор потока;
pthread_mutex_t — мютекс;
pthread_mutexattr_t — объект атрибутов мютекса
pthread_cond_t — условная переменная
pthread_condattr_t — объект атрибута условной переменной;
pthread_key_t — данные, специфичные для потока;
pthread_once_t — контекст контроля динамической инициализации;
pthread_attr_t — перечень атрибутов потока.

В традиционном Unix API код последней ошибки errno является глобальной int переменной. Это однако не годится для программ с множественными нитями исполнения. В ситуации, когда вызов функции в одном из исполняемых потоков завершился ошибкой в глобальной переменной errno , может возникнуть состояние гонки из-за того, что и остальные потоки могут в данный момент проверять код ошибки и оконфузиться. В Unix и Linux эту проблему обошли тем, что errno определяется как макрос, задающий для каждой нити собственное изменяемое lvalue .

Из man errno
Переменная errno определена в стандарте ISO C как изменяемое lvalue int и не объявляемая явно; errno может быть и макросом. Переменная errno является локальным значением нити; её изменение в одной нити не влияет на её значение в другой нити.

Создание потока

В начале создается потоковая функция. Затем новый поток создается функцией pthread_create() , объявленной в заголовочном файле pthread.h. Далее, вызывающая сторона продолжает выполнять какие-то свои действия параллельно потоковой функции.

При удачном завершении pthread_create() возвращает код 0, ненулевое значение сигнализирует об ошибке.

Первый параметр вызова pthread_create() является адресом для хранения идентификатора создаваемого потока типа pthread_t .
Аргумент start является указателем на потоковую void * функцию, принимающей бестиповый указатель в качестве единственной переменной.
Аргумент arg — это бестиповый указатель, содержащий аргументы потока. Чаще всего arg указывает на глобальную или динамическую переменную, но если вызываемая функция не требует наличия аргументов, то в качестве arg можно указать NULL .
Аргумент attr также является бестиповым указателем атрибутов потока pthread_attr_t . Если этот аргумент равен NULL , то поток создается с атрибутами по умолчанию.

Рассмотрим теперь пример многопоточной программы.

Чтобы подключить библиотеку Pthread к программе, нужно передать компоновщику опцию -lpthread .

О присоединении потока pthread_join расскажу чуть позже. Строка pthread_t tid задает идентификатор потока. Атрибуты функции задает pthread_attr_init(&attr) . Так как мы не задавали их явно, будут использованы значения по умолчанию.

Завершение потока

Поток завершает выполнение задачи когда:

потоковая функция выполняет return и возвращает результат произведенных вычислений;
в результате вызова завершения исполнения потока pthread_exit() ;
в результате вызова отмены потока pthread_cancel() ;
одна из нитей совершает вызов exit()
основная нить в функции main() выполняет return , и в таком случае все нити процесса резко сворачиваются.

Синтаксис проще, чем при создании потока.

Если в последнем варианте старшая нить из функции main() выполнит pthread_exit() вместо просто exit() или return , то тогда остальные нити продолжат исполняться, как ни в чем не бывало.

Ожидание потока

Функция pthread_join() ожидает завершения потока обозначенного THREAD_ID . Если этот поток к тому времени был уже завершен, то функция немедленно возвращает значение. Смысл функции в том, чтобы синхронизировать потоки. Она объявлена в pthread.h следующим образом:

При удачном завершении pthread_join() возвращает код 0, ненулевое значение сигнализирует об ошибке.

Если указатель DATA отличается от NULL , то туда помещаются данные, возвращаемые потоком через функцию pthread_exit() или через инструкцию return потоковой функции. Несколько потоков не могут ждать завершения одного. Если они пытаются выполнить это, один поток завершается успешно, а все остальные — с ошибкой ESRCH. После завершения pthread_join() , пространство стека связанное с потоком, может быть использовано приложением.

В каком-то смысле pthread_joini() похожа на вызов waitpid() , ожидающую завершения исполнения процесса, но с некоторыми отличиями. Во-первых, все потоки одноранговые, среди них отсутствует иерархический порядок, в то время как процессы образуют дерево и подчинены иерархии родитель — потомок. Поэтому возможно ситуация, когда поток А, породил поток Б, тот в свою очередь заделал В, но затем после вызова функции pthread_join() А будет ожидать завершения В или же наоборот. Во-вторых, нельзя дать указание одному ожидай завершение любого потока, как это возможно с вызовом waitpid(-1, &status, options) . Также невозможно осуществить неблокирующий вызов pthread_join() .

Досрочное завершение потока

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

При удачном завершении pthread_cancel() возвращает код 0, ненулевое значение сигнализирует об ошибке.

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

Небольшая иллюстрация создания и отмены потока.

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

Как мы видим есть вовсе неотменяемые потоки, а поведением по умолчанию является отложенное завершение, которое происходит в момент завершения. А откуда мы узнаем, что этот самый момент наступил? Для этого существует вспомогательная функция pthread_testcancel .

Отсоединение потока

Любому потоку по умолчанию можно присоединиться вызовом pthread_join() и ожидать его завершения. Однако в некоторых случаях статус завершения потока и возврат значения нам не интересны. Все, что нам надо, это завершить поток и автоматически выгрузить ресурсы обратно в распоряжение ОС. В таких случаях мы обозначаем поток отсоединившимся и используем вызов pthread_detach() .

При удачном завершении pthread_detach() возвращает код 0, ненулевое значение сигнализирует об ошибке.

Отсоединенный поток — это приговор. Его уже не перехватить с помощью вызова pthread_join() , чтобы получить статус завершения и прочие плюшки. Также нельзя отменить его отсоединенное состояние. Вопрос на засыпку. Что будет, если завершение потока не перехватить вызовом pthread_join() и чем это отлично от сценария, при котором завершился отсоединенный поток? В первом случае мы получим зомбо-поток, а во втором — все будет норм.

Потоки versus процессы

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

В начальной части статьи мы уже указывали на эти преимущество, поэтому вкратце их просто перечислим.

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

Теперь немного о недостатках.

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

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

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

В Linux потоки (а также LWP - Ligthweight Proccess - легкие процессы) созданные в пределах одной программы будут иметь такой же идентификатор группы потока как и PID программы. Каждый поток будет иметь свой собственный идентификатор потока (TID). Для планировщика ядра потоки ничем не отличаются от обычных процессов которые имеют общие ресурсы. Поэтому для просмотра потоков можно использовать такие классические инструменты командной строки как ps и top.

Ниже описаны несколько способов просмотра потоков процесса в linux

Способ первый: PS

В утилите ps показ потоков процесса включается опцией -T. Например вот такой командой можно посмотреть все потоки процесса с pid:

В колонке SPID отображается идентификатор потока, а в CMD его имя.

Способ два: top

Команда top позволяет просматривать потоки в реальном времени. Для включения отображения потоков запустите top с опцией -H. Также можно включить или отключить показ потоков во время выполнения с помощью клавиши H:

Если вы хотите посмотреть только потоки нужного процесса выполните:

Способ 3: htop

Ну и как всегда под конец самое интересное. Самой удобной утилитой для просмотра потоков процесса есть htop. Это основный на ncurces интерактивный просмотрщик процессов. С помощью этой утилиты вы можете наблюдать за потоками в реальном времени в виде дерева.

Для того чтобы включить просмотр потоков в htop откройте программу, войдите в меню нажав клавишу F2, затем выберите Display Options, в разделе Setup. Теперь отметьте "Three view" и "Show custom thread names". Все, можно нажимать F10 для сохранения настроек:

Теперь вы можете просматривать потоки в виде дерева отдельно для каждого процесса:

Читайте также: