Различие между процессами и потоками в Linux
После прочтения этого ответа и "Разработка ядра Linux" Робертом Лавом, а затем clone() Системный вызов, я обнаружил, что процессы и потоки в Linux (почти) неразличимы для ядра. Между ними есть несколько хитростей (обсуждаемых как "больше делиться" или "меньше делиться" в цитируемом вопросе SO), но у меня все еще есть некоторые вопросы, на которые еще предстоит ответить.
Недавно я работал над программой, включающей пару потоков POSIX, и решил поэкспериментировать с этой предпосылкой. В процессе, который создает два потока, все потоки, конечно, получают уникальное значение, возвращаемое pthread_self()однако не getpid(),
Пример программы, которую я создал, выглядит следующим образом:
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <pthread.h>
void* threadMethod(void* arg)
{
int intArg = (int) *((int*) arg);
int32_t pid = getpid();
uint64_t pti = pthread_self();
printf("[Thread %d] getpid() = %d\n", intArg, pid);
printf("[Thread %d] pthread_self() = %lu\n", intArg, pti);
}
int main()
{
pthread_t threads[2];
int thread1 = 1;
if ((pthread_create(&threads[0], NULL, threadMethod, (void*) &thread1))
!= 0)
{
fprintf(stderr, "pthread_create: error\n");
exit(EXIT_FAILURE);
}
int thread2 = 2;
if ((pthread_create(&threads[1], NULL, threadMethod, (void*) &thread2))
!= 0)
{
fprintf(stderr, "pthread_create: error\n");
exit(EXIT_FAILURE);
}
int32_t pid = getpid();
uint64_t pti = pthread_self();
printf("[Process] getpid() = %d\n", pid);
printf("[Process] pthread_self() = %lu\n", pti);
if ((pthread_join(threads[0], NULL)) != 0)
{
fprintf(stderr, "Could not join thread 1\n");
exit(EXIT_FAILURE);
}
if ((pthread_join(threads[1], NULL)) != 0)
{
fprintf(stderr, "Could not join thread 2\n");
exit(EXIT_FAILURE);
}
return 0;
}
(Это было скомпилировано [gcc -pthread -o thread_test thread_test.c] на 64-битной Fedora; из-за 64-битных типов, используемых для pthread_t получены из <bits/pthreadtypes.h>, код потребует незначительных изменений для компиляции в 32-разрядных выпусках.)
Вывод, который я получаю, выглядит следующим образом:
[bean@fedora ~]$ ./thread_test
[Process] getpid() = 28549
[Process] pthread_self() = 140050170017568
[Thread 2] getpid() = 28549
[Thread 2] pthread_self() = 140050161620736
[Thread 1] getpid() = 28549
[Thread 1] pthread_self() = 140050170013440
[bean@fedora ~]$
Используя блокировку планировщика в gdbЯ могу сохранить программу и ее потоки, чтобы я мог захватить то, что top говорит, что, просто показывая процессы, это:
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
28602 bean 20 0 15272 1112 820 R 0.4 0.0 0:00.63 top
2036 bean 20 0 108m 1868 1412 S 0.0 0.0 0:00.11 bash
28547 bean 20 0 231m 16m 7676 S 0.0 0.4 0:01.56 gdb
28549 bean 20 0 22688 340 248 t 0.0 0.0 0:00.26 thread_test
28561 bean 20 0 107m 1712 1356 S 0.0 0.0 0:00.07 bash
И когда показывает темы, говорит:
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
28617 bean 20 0 15272 1116 820 R 47.2 0.0 0:00.08 top
2036 bean 20 0 108m 1868 1412 S 0.0 0.0 0:00.11 bash
28547 bean 20 0 231m 16m 7676 S 0.0 0.4 0:01.56 gdb
28549 bean 20 0 22688 340 248 t 0.0 0.0 0:00.26 thread_test
28552 bean 20 0 22688 340 248 t 0.0 0.0 0:00.00 thread_test
28553 bean 20 0 22688 340 248 t 0.0 0.0 0:00.00 thread_test
28561 bean 20 0 107m 1860 1432 S 0.0 0.0 0:00.08 bash
Кажется совершенно ясным, что программы, или, возможно, ядро, имеют отличный способ определения потоков в отличие от процессов. Каждый поток имеет свой собственный PID в соответствии с top - Зачем?
3 ответа
Все эти заблуждения проистекают из того факта, что разработчики ядра изначально придерживались иррационального и неправильного мнения о том, что потоки могут быть реализованы почти полностью в пользовательском пространстве с использованием процессов ядра в качестве примитива, при условии, что ядро предложило способ заставить их совместно использовать память и файловые дескрипторы, Это привело к общеизвестно плохой реализации потоков POSIX в LinuxThreads, что было ошибочным, потому что не давало ничего похожего на семантику потоков POSIX. В конце концов LinuxThreads был заменен (NPTL), но многие запутанные терминологии и недоразумения сохраняются.
Первое и самое важное, что нужно понять, это то, что "PID" означает разные вещи в пространстве ядра и в пространстве пользователя. То, что ядро называет PID, на самом деле является идентификатором потока на уровне ядра (часто называемым TID), его не следует путать с pthread_t который является отдельным идентификатором. Каждый поток в системе, будь то в том же процессе или в другом, имеет уникальный TID (или "PID" в терминологии ядра).
То, что считается PID в смысле "процесса" в POSIX, с другой стороны, называется "идентификатором группы потоков" или "TGID" в ядре. Каждый процесс состоит из одного или нескольких потоков (процессов ядра), каждый из которых имеет свой собственный TID (PID ядра), но все они используют один и тот же TGID, который равен TID (PID ядра) исходного потока, в котором main пробеги.
когда top показывает потоки, показывает TID (идентификаторы ядра), а не PID (идентификаторы ядра), и поэтому каждый поток имеет отдельный.
С появлением NPTL большинство системных вызовов, которые принимают аргумент PID или воздействуют на вызывающий процесс, были изменены, чтобы обрабатывать PID как TGID и воздействовать на всю "группу потоков" (процесс POSIX).
Представьте себе какую-то "мета-сущность". Если сущность не разделяет ни один из ресурсов (адресное пространство, файловые дескрипторы и т. Д.) Своего родителя, то это процесс, а если сущность разделяет все ресурсы своего родителя, то это поток. Вы могли бы даже иметь что-то среднее между процессом и потоком (например, некоторые ресурсы совместно используются, а некоторые - нет). Взгляните на системный вызов "clone()" (например, http://linux.die.net/man/2/clone), и вы увидите, как Linux работает внутренне.
Теперь спрячьте это за какой-то абстракцией, которая делает все похожим на процесс или поток. Если абстракция безупречна, вы никогда не узнаете разницу между "сущностями" и "процессами и потоками". Абстракция не совсем безупречна - PID, который вы видите, на самом деле является "идентификатором сущности".
В Linux каждый поток получает идентификатор потока. Идентификатор потока основного потока выполняет двойную функцию в качестве идентификатора процесса (и довольно хорошо известен в пользовательском интерфейсе). Идентификатор потока - это деталь реализации Linux, не связанная с идентификатором POSIX. Для получения более подробной информации обратитесь к системному вызову gettid (недоступно для чистого Python, поскольку он зависит от системы).