В чем разница между процессом и потоком?

Процесс
Каждый процесс предоставляет ресурсы, необходимые 9X_threads для выполнения программы. Процесс имеет 9X_threading виртуальное адресное пространство, исполняемый 9X_threading код, открытые дескрипторы для системных 9X_multi-threaded объектов, контекст безопасности, уникальный 9X_processes идентификатор процесса, переменные среды, класс 9X_threading приоритета, минимальный и максимальный размеры 9X_multithread рабочего набора и, по крайней мере, один 9X_operating-systems поток выполнения. Каждый процесс запускается 9X_multithreading одним потоком, часто называемым основным 9X_thread потоком, но может создавать дополнительные 9X_processes потоки из любого из своих потоков.

Тема
Поток 9X_process - это объект внутри процесса, который можно 9X_os запланировать для выполнения. Все потоки 9X_thread процесса совместно используют его виртуальное 9X_threads адресное пространство и системные ресурсы. Кроме 9X_thread того, каждый поток поддерживает обработчики 9X_multithreading исключений, приоритет планирования, локальное 9X_processes хранилище потока, уникальный идентификатор 9X_threading потока и набор структур, которые система 9X_os будет использовать для сохранения контекста 9X_threading потока, пока он не будет запланирован. Контекст 9X_os потока включает набор машинных регистров 9X_threading потока, стек ядра, блок среды потока и пользовательский 9X_os стек в адресном пространстве процесса потока. Потоки 9X_multithread также могут иметь собственный контекст безопасности, который 9X_operating-system можно использовать для олицетворения клиентов.

Эта 9X_os информация была найдена в Microsoft Docs 9X_threads здесь: About Processes and Threads

Microsoft Windows поддерживает вытесняющую 9X_threads многозадачность, что создает эффект одновременного 9X_operating-systems выполнения нескольких потоков из нескольких 9X_multithreading процессов. На многопроцессорном компьютере 9X_threads система может одновременно выполнять столько 9X_multi-threaded потоков, сколько процессоров на компьютере.

Процесс:

• Выполняемый экземпляр программы называется процессом.
• В некоторых операционных системах термин «задача» используется для обозначения выполняемой программы.
• Процесс всегда хранится в основной памяти, также называемой первичной памятью или оперативной памятью.
• Таким образом, процесс называется активным объектом. Он исчезает при перезагрузке машины.
• С одной программой могут быть связаны несколько процессов.
• В многопроцессорной системе несколько процессов могут выполняться параллельно.
• В однопроцессорной системе, хотя истинный параллелизм не достигается, применяется алгоритм планирования процессов, и процессор планирует выполнять каждый процесс по одному, создавая иллюзию параллелизма.
• Пример: выполнение нескольких экземпляров программы «Калькулятор». Каждый из экземпляров называется процессом.

Тема:

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

Приведенную выше информацию я позаимствовал 9X_multi-threaded из Knowledge Quest! blog.

Сначала рассмотрим теоретический аспект. Вам 9X_operating-systems необходимо понять, что такое процесс концептуально, чтобы 9X_multi-threaded понять разницу между процессом и потоком, а 9X_operating-system также то, что разделяется между ними.

В разделе 9X_process 2.2.2 Классическая модель потока статьи Modern Operating Systems 3e Таненбаума содержится следующее:

Модель 9X_multithread процесса основана на двух независимых концепциях: ресурс группировка 9X_multithread и исполнение. Иногда бывает полезно их разделить; здесь 9X_threading и появляются темы ....

Он продолжает:

Один 9X_threads из способов взглянуть на процесс - это способ группируйте 9X_cross-threading связанные ресурсы вместе. У процесса есть 9X_operating-system адресное пространство содержащие текст и 9X_thread данные программы, а также другие ресурсы. Эти ресурс 9X_threading может включать открытые файлы, дочерние 9X_threading процессы, ожидающие тревоги, обработчики 9X_processes сигналов, учетная информация и многое другое. Положив 9X_multi-threaded их вместе в форме процесса ими можно легче 9X_operating-systems управлять. Другая концепция процесса - это 9X_os поток выполнения, обычно укороченный до 9X_multithread простой нити. У потока есть программный 9X_threading счетчик, который хранит отслеживать, какую 9X_operating-system инструкцию выполнить следующей. Имеет регистры, которые сохранить 9X_multithreading текущие рабочие переменные. У него есть 9X_process стек, который содержит история выполнения, с 9X_operating-system одним кадром для каждой вызванной процедуры, но 9X_processes не пока не вернулся из. Хотя поток должен 9X_process выполняться в каком-то процессе, поток и 9X_operating-system его процесс - это разные концепции, и их 9X_processes можно рассматривать отдельно. Процессы используются 9X_operating-systems для группировки ресурсов вместе; потоки - это 9X_os объекты, запланированные для выполнения 9X_process на ЦП.

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

Per process items | Per thread items ------------------------------|----------------- Address space | Program counter Global variables | Registers Open files | Stack Child processes | State Pending alarms | Signals and signal handlers | Accounting information | 

Давайте 9X_process разберемся с проблемой hardware multithreading. Классически ЦП 9X_threading будет поддерживать один поток выполнения, поддерживая 9X_operating-system состояние потока с помощью одного program counter (ПК) и 9X_operating-system набора регистров. Но что происходит, когда 9X_operating-system происходит промах кеша? Извлечение данных 9X_processes из основной памяти занимает много времени, и 9X_process пока это происходит, ЦП просто бездействует. Итак, кому-то 9X_multi-threaded пришла в голову идея иметь в основном два 9X_process набора состояний потока (ПК + регистры), чтобы 9X_operating-systems другой поток (возможно, в том же процессе, может 9X_multi-threaded быть, в другом процессе) мог выполнять работу, пока 9X_processes другой поток ожидает в основной памяти. Есть 9X_multithreading несколько названий и реализаций этой концепции, например 9X_threads Hyper-threading и simultaneous multithreading (сокращенно SMT).

Теперь посмотрим на 9X_operating-systems программное обеспечение. Существует три 9X_multithreading основных способа реализации потоков на программной 9X_processes стороне.

1. Темы пользовательского пространства
2. Потоки ядра
3. Сочетание двух

Все, что вам нужно для реализации 9X_multi-threaded потоков, - это возможность сохранять состояние 9X_multi-threaded процессора и поддерживать несколько стеков, что 9X_multi-threaded во многих случаях может быть выполнено в 9X_operating-system пользовательском пространстве. Преимуществом 9X_multithread потоков пользовательского пространства является 9X_multi-threaded сверхбыстрое переключение потоков, поскольку 9X_process вам не нужно ограничиваться ядром, и возможность 9X_processes планировать потоки так, как вам нравится. Самый 9X_thread большой недостаток - это невозможность блокировать 9X_os ввод-вывод (который заблокировал бы весь 9X_multithreading процесс и все его пользовательские потоки), что 9X_cross-threading является одной из основных причин, по которой 9X_processes мы в первую очередь используем потоки. Блокирование 9X_threading ввода-вывода с помощью потоков во многих 9X_multithread случаях значительно упрощает разработку 9X_operating-system программы.

Потоки ядра имеют то преимущество, что 9X_cross-threading они могут использовать блокирующий ввод-вывод 9X_operating-system в дополнение к тому, что все вопросы планирования 9X_thread остаются на усмотрение ОС. Но для каждого 9X_os переключения потока требуется захват ядра, что 9X_operating-system потенциально относительно медленно. Однако, если 9X_thread вы переключаете потоки из-за заблокированного 9X_threads ввода-вывода, это не проблема, поскольку 9X_operating-system операция ввода-вывода, вероятно, в любом 9X_threading случае уже захватила вас в ядре.

Другой подход 9X_multithreading заключается в объединении этих двух потоков 9X_operating-systems с несколькими потоками ядра, каждый из которых 9X_processes имеет несколько пользовательских потоков.

Итак, возвращаясь 9X_operating-system к вопросу о терминологии, вы можете видеть, что 9X_operating-system процесс и поток выполнения - это две разные 9X_processes концепции, и ваш выбор термина зависит от 9X_operating-system того, о чем вы говорите. Что касается термина 9X_cross-threading «легковесный процесс», я лично не вижу в 9X_threading нем смысла, поскольку он на самом деле не 9X_multithreading передает, что происходит, а также термин 9X_cross-threading «поток выполнения».

Чтобы объяснить больше в отношении параллельного 9X_multithreading программирования

1. Процесс имеет автономную 9X_processes среду выполнения. Обычно процесс имеет полный 9X_processes частный набор основных ресурсов времени 9X_process выполнения; в частности, каждый процесс 9X_thread имеет собственное пространство памяти.

2. Внутри 9X_cross-threading процесса существуют потоки - у каждого процесса 9X_processes есть хотя бы один. Потоки совместно используют 9X_thread ресурсы процесса, включая память и открытые 9X_operating-systems файлы. Это делает общение эффективным, но 9X_process потенциально проблематичным.

Пример для среднего 9X_processes человека:

На вашем компьютере откройте Microsoft 9X_threading Word и веб-браузер. Мы называем эти два 9X_threading процесса процессами.

В Microsoft Word вы вводите что-то, и 9X_threading это автоматически сохраняется. Вы заметили, что 9X_threads редактирование и сохранение происходят параллельно 9X_multi-threaded - редактирование в одном потоке и сохранение 9X_cross-threading в другом.

Приложение состоит из одного или нескольких 9X_multithread процессов. Проще говоря, процесс - это исполняемая 9X_processes программа. Один или несколько потоков выполняются 9X_thread в контексте процесса. Поток - это базовая 9X_thread единица, которой операционная система выделяет 9X_processes процессорное время. Поток может выполнять 9X_operating-systems любую часть кода процесса, включая части, выполняемые 9X_os в данный момент другим потоком. Волокно 9X_processes - это единица выполнения, которую приложение 9X_cross-threading должно запланировать вручную. Волокна работают 9X_multithread в контексте потоков, которые их планируют.

Похищено 9X_threading с here.

Процесс - это совокупность кода, памяти, данных 9X_multi-threaded и других ресурсов. Поток - это последовательность 9X_threading кода, которая выполняется в рамках процесса. Вы 9X_processes можете (обычно) иметь несколько потоков, выполняющихся 9X_process одновременно в одном процессе.

Процесс:

1. Процесс - это тяжелый процесс.
2. Процесс - это отдельная программа, которая имеет отдельную память, данные, ресурсы и т. д.
3. Процессы создаются с использованием метода fork().
4. Переключение контекста между процессами занимает много времени.
   

Пример:
Скажем, открытие любого браузера 9X_threading (Mozilla, Chrome, IE). На этом этапе начнется 9X_os выполнение нового процесса.

Темы:

1. Потоки - это легковесные процессы. Потоки объединяются внутри процесса.
2. У потоков есть общая память, данные, ресурсы, файлы и т. д.
3. Потоки создаются с помощью метода clone().
4. Переключение контекста между потоками занимает не так много времени, как процесс.
   

Реальный пример для процесса и потока Это даст вам общее представление о потоке и процессе

Я позаимствовал приведенную выше информацию из ответа Скотта Лэнгхэма - спасибо

9X_process

• Каждый процесс - это поток (основной поток).
• Но каждый поток - это не процесс. Это часть (сущность) процесса.

9X_processes

И потоки, и процессы являются атомарными 9X_thread единицами распределения ресурсов ОС (т. е. существует 9X_thread модель параллелизма, описывающая, как распределяется 9X_operating-system время ЦП между ними, и модель владения другими 9X_multithread ресурсами ОС). Есть разница в:

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

Выше Грег 9X_processes Хьюгилл был прав относительно значения слова 9X_multi-threaded "процесс" в Erlang, и here обсуждается, почему 9X_cross-threading Erlang может облегчить процессы.

Пытаюсь ответить на этот вопрос, касающийся 9X_operating-systems мира Java.

Процесс - это выполнение программы, а 9X_os поток - это отдельная последовательность 9X_operating-system выполнения внутри процесса. Процесс может 9X_os содержать несколько потоков. Поток иногда 9X_cross-threading называют облегченным процессом.

Например:

Пример 1: JVM работает 9X_threads в одном процессе, а потоки в JVM совместно 9X_processes используют кучу, принадлежащую этому процессу. Вот 9X_threads почему несколько потоков могут обращаться 9X_thread к одному и тому же объекту. Потоки совместно 9X_thread используют кучу и имеют собственное пространство 9X_multi-threaded стека. Таким образом, вызов метода одним 9X_operating-system потоком и его локальные переменные сохраняются 9X_operating-systems в потокобезопасности от других потоков. Но 9X_thread куча не является потокобезопасной и должна 9X_threading быть синхронизирована для обеспечения безопасности 9X_threading потоков.

Пример 2: Программа может не рисовать 9X_os изображения, считывая нажатия клавиш. Программа 9X_process должна уделять все свое внимание вводу с 9X_threads клавиатуры, и отсутствие возможности обрабатывать 9X_operating-systems более одного события одновременно приведет 9X_cross-threading к проблемам. Идеальное решение этой проблемы 9X_thread - бесшовное выполнение двух или более разделов 9X_threads программы одновременно. Threads позволяет 9X_multi-threaded нам это делать. Здесь Рисование изображения 9X_process - это процесс, а чтение нажатия клавиши 9X_threads - это подпроцесс (поток).

http://lkml.iu.edu/hypermail/linux/kernel/9608/0191.html

Линус Торвальдс ([email protected])

Вт, 6 9X_cross-threading августа 1996 г. 12:47:31 +0300 (EET DST)

Сообщения 9X_process отсортированы по: [дате] [теме] [теме] [автору]

Следующее 9X_threading сообщение: Бернд П. Циллер: "Re: Oops 9X_multithread in get_hash_table"

Предыдущее сообщение: Линус 9X_processes Торвальдс: "Re: заказ ввода-вывода"

В 9X_os понедельник, 5 августа 1996 г., Питер П. Эйзерло 9X_multithread написал:

Нам нужно четко понимать понятие 9X_threading потоков. Слишком много людей кажется, путают 9X_os поток с процессом. Следующее обсуждение не 9X_multi-threaded отражает текущее состояние Linux, а скорее 9X_cross-threading является попытаться оставаться на высоком 9X_operating-system уровне обсуждения.

НЕТ!

Нет оснований полагать, что 9X_multithread «потоки» и «процессы» отдельные сущности. Так 9X_process обычно и делается, но я лично считаю, что 9X_multithread так думать - это большая ошибка. Единственный причина 9X_threading так думать - это исторический багаж.

И потоки, и 9X_multithreading процессы на самом деле одно: "контекст казнь 9X_multi-threaded ». Пытаться искусственно различать разные 9X_cross-threading случаи - это просто самоограничивающийся.

"Контекст 9X_process исполнения", именуемый далее COE, - это 9X_thread всего лишь конгломерат всего состояния 9X_threads этого COE. Это состояние включает в себя 9X_threading такие вещи, как CPU состояние (регистры 9X_operating-system и т. д.), состояние MMU (сопоставления страниц), состояние 9X_process разрешения (uid, gid) и различные "состояния 9X_processes связи" (открытые файлы, сигнал обработчики 9X_os и т. д.). Традиционно разница между «нитью» и "процесс" в 9X_multithreading основном заключался в том, что потоки имеют 9X_operating-systems состояние ЦП (+ возможно какое-то другое 9X_operating-system минимальное состояние), в то время как весь 9X_operating-system другой контекст исходит из процесс. Однако 9X_threads это просто один способ разделить общее состояние 9X_operating-systems COE, и нет ничего, что говорило бы о том, что 9X_thread это правильный способ сделать это. Ограничение 9X_os себя к такому образу просто глупо.

Linux 9X_processes думает об этом (и я хочу, чтобы все работало) так: что 9X_thread не существует таких вещей, как "процесс" или 9X_multithread "поток". Там есть только совокупность 9X_threads COE (называемая в Linux «задачей»). Различные 9X_cross-threading COE могут делиться друг с другом частями 9X_threading своего контекста, а одно подмножество этот совместный 9X_cross-threading доступ является традиционной настройкой 9X_multi-threaded "поток" / "процесс", но 9X_thread это действительно следует рассматривать 9X_process ТОЛЬКО как подмножество (это важное подмножество, но это 9X_multi-threaded значение исходит не от дизайна, а от стандартов: очевидно, что 9X_multi-threaded мы хотите запускать соответствующие стандартам 9X_cross-threading программы потоков поверх Linux тоже).

Вкратце: НЕ 9X_cross-threading проектируйте, основываясь на образе мышления 9X_operating-systems потоков / процессов. В ядро должно быть 9X_processes спроектировано с учетом образа мышления 9X_processes COE, а затем библиотека pthreads может экспортировать 9X_multithread ограниченный интерфейс pthreads для пользователей кто 9X_multithreading хочет использовать этот способ взгляда на 9X_process COE.

Просто в качестве примера того, что 9X_process становится возможным, если вы думаете о 9X_os COE как о в отличие от потока / процесса:

• Вы можете создать внешнюю программу "cd", что традиционно невозможно в UNIX и / или процессе / потоке (глупый пример, но идея в том, что у вас могут быть такие «модули», которые не ограничиваются традиционная настройка UNIX / нитей). Сделайте:

клон 9X_operating-systems (CLONE_VM | CLONE_FS);

child: execve ("external-cd");

/ * "execve()" разъединяет 9X_thread виртуальную машину, поэтому единственная 9X_operating-system причина, по которой мы используется CLONE_VM, чтобы 9X_threads ускорить процесс клонирования * /

• Вы можете выполнить "vfork()" естественным образом (он требует минимальной поддержки ядра, но эта поддержка полностью соответствует образу мышления CUA):

клон (CLONE_VM);

потомок: продолжить 9X_multithread выполнение, в конечном итоге execve()

мать: подожди 9X_os execve

• вы можете выполнять внешние «демоны ввода-вывода»:

клон (CLONE_FILES);

дочерний: дескрипторы 9X_multithread открытых файлов и т. д.

мать: используйте 9X_operating-systems файлы, открытые ребенком, и vv.

Все вышеперечисленное 9X_cross-threading работает, потому что вы не привязаны к потоку 9X_multithread / процессу способ мышления. Подумайте, например, о 9X_threading веб-сервере, где CGI сценарии выполняются 9X_threading как «потоки выполнения». Вы не можете сделать 9X_operating-systems это с традиционные потоки, потому что 9X_processes традиционные потоки всегда должны разделять все 9X_threads адресное пространство, поэтому вам придется 9X_os связывать все, что вы когда-либо хотел 9X_thread сделать на самом веб-сервере («поток» не 9X_processes может запустить другой исполняемый файл).

Рассматривая 9X_process это как проблему "контекста выполнения", ваша задачи 9X_thread теперь могут выбрать выполнение внешних 9X_multithread программ (= отделить адресное пространство 9X_multi-threaded от родителя) и т. д., если они хотят, или 9X_cross-threading они могут для пример поделиться всем с 9X_os родительским кроме для файла дескрипторы (так 9X_thread что под- "потоки" могут открывать 9X_multithreading множество файлов без родитель должен беспокоиться 9X_thread о них: они закрываются автоматически, когда под- "поток" завершается, и 9X_thread он не использует fd в родительском).

Например, подумайте 9X_threads о многопоточном inetd. Вы хотите низкие 9X_process накладные расходы fork + exec, поэтому 9X_operating-systems с помощью Linux вы можете вместо использования 9X_multi-threaded "fork()" вы пишете многопоточный 9X_thread inetd, где каждый поток создается с просто 9X_multi-threaded CLONE_VM (разделяйте адресное пространство, но 9X_os не делитесь файловыми дескрипторами так 9X_processes далее). Затем дочерний элемент может выполнить 9X_processes execve, если это была внешняя служба (rlogind, например), или, может 9X_multithread быть, это была одна из внутренних служб 9X_threads inetd (echo, timeofday), и в этом случае 9X_multithreading он просто выполняет свою задачу и завершает 9X_threading работу.

Вы не можете этого сделать с "потоком" / "процессом".

Линус

Попытка ответить на него из обзора ОС ядра 9X_process Linux

При запуске в память программа становится 9X_operating-systems процессом. У процесса есть собственное адресное 9X_multithread пространство, что означает наличие различных 9X_process сегментов в памяти, таких как сегмент .text для 9X_operating-system хранения скомпилированного кода, .bss для хранения 9X_multithreading неинициализированных статических или глобальных 9X_threading переменных и т. Д.
Каждый процесс будет 9X_threading иметь свой собственный счетчик программ 9X_threads и пользовательское пространство стек.

Внутри 9X_threading ядра каждый процесс будет иметь свой собственный 9X_multithreading стек ядра (который отделен от стека пользовательского 9X_multithreading пространства из-за проблем безопасности) и 9X_multithreading структуру с именем task_struct, которая обычно абстрагируется 9X_thread как блок управления процессом, в которой 9X_operating-system хранятся все информация о процессе, такая 9X_multithread как его приоритет, состояние (и многое другое).
Процесс 9X_processes может иметь несколько потоков выполнения.

Переходя 9X_threads к потокам, они находятся внутри процесса 9X_operating-system и совместно используют адресное пространство 9X_os родительского процесса вместе с другими 9X_threading ресурсами, которые могут быть переданы во 9X_multithread время создания потока, такими как ресурсы 9X_operating-systems файловой системы, совместное использование 9X_cross-threading ожидающих сигналов, совместное использование 9X_operating-system данных (переменных и инструкций), таким 9X_threads образом делая потоки легкие и, следовательно, позволяют 9X_threads более быстрое переключение контекста.

Внутри 9X_processes ядра каждый поток имеет свой собственный 9X_operating-system стек ядра вместе со структурой task_struct, которая 9X_threading определяет поток. Таким образом, ядро ​​рассматривает 9X_process потоки одного и того же процесса как разные 9X_processes объекты, и их можно планировать сами по 9X_multithreading себе. Потоки в одном процессе имеют общий 9X_multi-threaded идентификатор, называемый идентификатором 9X_multithreading группы потоков (tgid), также у них есть уникальный 9X_operating-systems идентификатор, называемый идентификатором 9X_cross-threading процесса (pid).

Для тех, кому удобнее учиться с помощью 9X_operating-systems визуализации, вот удобная диаграмма, которую 9X_process я создал для объяснения процессов и потоков.
Я 9X_threading использовал информацию из MSDN - About Processes and Threads

И процессы, и потоки являются независимыми 9X_multi-threaded последовательностями выполнения. Типичное 9X_operating-system отличие состоит в том, что потоки (одного 9X_operating-system и того же процесса) выполняются в общем 9X_processes пространстве памяти, а процессы - в отдельных 9X_multithreading пространствах памяти.

Процесс

Выполняется 9X_os программа. он имеет текстовый раздел, то 9X_multi-threaded есть программный код, текущую активность, представленную 9X_multithreading значением счетчика программ и содержимым 9X_multithread регистра процессоров. Он также включает 9X_threading стек процесса, который содержит временные 9X_thread данные (такие как параметры функции, адреса 9X_processes возврата и локальные переменные), и раздел 9X_multithreading данных, который содержит глобальные переменные. Процесс 9X_multithread также может включать в себя кучу, которая 9X_thread представляет собой память, динамически выделяемую 9X_multithreading во время выполнения процесса.

Тема

Поток - это 9X_threading основная единица использования ЦП; он состоит 9X_threads из идентификатора потока, счетчика программ, набора 9X_multithread регистров и стека. он разделяет с другими 9X_processes потоками, принадлежащими тому же процессу, его 9X_process раздел кода, раздел данных и другие ресурсы 9X_cross-threading операционной системы, такие как открытые 9X_threads файлы и сигналы.

- Взято из операционной 9X_os системы Галвином

Процесс:

Процесс - это, по сути, выполняемая программа. Это 9X_threads активная сущность. Некоторые операционные 9X_operating-systems системы используют термин «задача» для обозначения 9X_operating-system выполняемой программы. Процесс всегда хранится 9X_multithreading в основной памяти, также называемой первичной 9X_multi-threaded памятью или оперативной памятью. Следовательно, процесс 9X_threading называется активным объектом. Он исчезает 9X_cross-threading при перезагрузке машины. С одной программой 9X_operating-system могут быть связаны несколько процессов. В 9X_multi-threaded многопроцессорной системе несколько процессов 9X_os могут выполняться параллельно. В однопроцессорной 9X_threading системе, хотя истинный параллелизм не достигается, применяется 9X_operating-system алгоритм планирования процессов, и процессор 9X_threads планирует выполнять каждый процесс по одному, создавая 9X_operating-system иллюзию параллелизма. Пример: выполнение 9X_threading нескольких экземпляров программы «Калькулятор». Каждый 9X_multi-threaded из экземпляров называется процессом.

Тема:

Поток 9X_operating-systems - это часть процесса. Его называют «легковесным 9X_process процессом», поскольку он похож на реальный 9X_processes процесс, но выполняется в контексте процесса 9X_process и использует те же ресурсы, которые выделяются 9X_threading процессу ядром. Обычно процесс имеет только 9X_os один поток управления - один набор машинных 9X_operating-systems инструкций, выполняемых одновременно. Процесс 9X_multi-threaded также может состоять из нескольких потоков 9X_multithread выполнения, которые выполняют инструкции 9X_operating-system одновременно. Несколько потоков управления 9X_cross-threading могут использовать настоящий параллелизм, возможный 9X_thread в многопроцессорных системах. В однопроцессорной 9X_multithread системе применяется алгоритм планирования 9X_process потоков, и процессор планирует запускать 9X_thread каждый поток по одному. Все потоки, выполняемые 9X_threads в рамках процесса, используют одно и то 9X_multithread же адресное пространство, файловые дескрипторы, стек 9X_multithread и другие атрибуты, связанные с процессом. Поскольку 9X_multithreading потоки процесса используют одну и ту же 9X_multi-threaded память, синхронизация доступа к общим данным 9X_os внутри процесса приобретает беспрецедентную 9X_multithreading важность.

ref- https://practice.geeksforgeeks.org/problems/difference-between-process-and-thread

1. Поток выполняется в общем пространстве памяти, но процесс выполняется в отдельном пространстве памяти.
2. Поток - это легкий процесс, но процесс тяжелый.
3. Поток - это подтип процесса.

9X_processes

Difference between Thread and Process?

Процесс - это исполняемый экземпляр приложения, а 9X_multi-threaded поток - это путь выполнения внутри процесса. Кроме 9X_threads того, процесс может содержать несколько 9X_cross-threading потоков. Важно отметить, что поток может 9X_threading делать все, что может сделать процесс. Но 9X_process поскольку процесс может состоять из нескольких 9X_cross-threading потоков, поток можно считать «легким» процессом. Таким 9X_multi-threaded образом, существенное различие между потоком 9X_os и процессом - это работа, которую каждый 9X_processes из них выполняет. Потоки используются для 9X_thread небольших задач, тогда как процессы используются 9X_threading для более «тяжелых» задач - в основном для 9X_multithread выполнения приложений.

Еще одно различие 9X_threads между потоком и процессом заключается в 9X_thread том, что потоки одного процесса используют 9X_multithreading одно и то же адресное пространство, а разные 9X_thread процессы - нет. Это позволяет потокам читать 9X_threading и записывать в одни и те же структуры данных 9X_multi-threaded и переменные, а также упрощает обмен данными 9X_threads между потоками. Связь между процессами, также 9X_threading известная как IPC, или межпроцессное взаимодействие, довольно 9X_process сложная и ресурсоемкая.

Вот краткое описание 9X_operating-systems различий между потоками и процессами:

1. Создавать 9X_processes потоки легче, чем процессы, поскольку они не 9X_operating-systems требуют отдельного адресного пространства.

2. Многопоточность 9X_thread требует тщательного программирования, поскольку 9X_operating-systems потоки обмениваться структурами данных, которые 9X_os должны быть изменены только одним потоком вовремя. В 9X_processes отличие от потоков, процессы не используют 9X_multithreading одни и те же адресное пространство.

3. Потоки 9X_threads считаются легковесными, поскольку в них 9X_operating-systems используются меньше ресурсов, чем процессы.

4. Процессы 9X_threading независимы друг от друга. Темы, поскольку 9X_operating-system они разделяют одно и то же адресное пространство 9X_multi-threaded взаимозависимы, поэтому будьте осторожны нужно 9X_multithreading принимать так, чтобы разные нити не наступали 9X_os друг на друга.
   Это действительно еще один 9X_process способ заявить № 2 выше.

5. Процесс может состоять 9X_cross-threading из нескольких потоков.

Вот что я получил из одной из статей на 9X_cross-threading The Code Project. Думаю, он ясно объясняет все, что нужно.

Поток 9X_threading - это еще один механизм разделения рабочей 9X_threading нагрузки на отдельные потоки исполнения. Нить 9X_process легче, чем процесс. Этот означает, что 9X_thread он предлагает меньшую гибкость, чем полномасштабный 9X_cross-threading процесс, но может запускаться быстрее, потому 9X_threads что операционная система меньше настраивать. Когда 9X_os программа состоит из двух или более потоков, все потоки 9X_processes совместно используют одну область памяти. Процессам 9X_multithread выделяются отдельные адресные пространства. все 9X_os потоки используют одну кучу. Но каждому 9X_threads потоку дается свой стек.

С точки зрения интервьюера, я хочу услышать 9X_operating-system всего 3 основные вещи, помимо очевидных 9X_cross-threading вещей, таких как процесс может иметь несколько 9X_process потоков:

1. Потоки совместно используют одно и то же пространство памяти, что означает, что поток может получать доступ к памяти из памяти другого потока. Процессы нормально не могут.
2. Ресурсы. Ресурсы (память, дескрипторы, сокеты и т. Д.) Освобождаются при завершении процесса, а не при завершении потока.
3. Безопасность. У процесса есть фиксированный токен безопасности. С другой стороны, поток может олицетворять разных пользователей / токены.

Если вы хотите большего, ответ Скотта 9X_os Лэнгема охватывает почти все. Все это с 9X_multithread точки зрения операционной системы. Разные 9X_multi-threaded языки могут реализовывать разные концепции, такие 9X_os как задачи, легкие потоки и так далее, но 9X_processes это всего лишь способы использования потоков 9X_thread (волокон в Windows). Нет аппаратных и программных 9X_threading потоков. Существуют аппаратные и программные 9X_os исключения и прерывания или потоки пользовательского режима и ядра.

Исходя из мира встраиваемых систем, я хотел 9X_cross-threading бы добавить, что концепция процессов существует 9X_multithreading только в «больших» процессорах (настольные процессоры, ARM Cortex A-9), которые 9X_multithreading имеют MMU (блок управления памятью ) и операционные 9X_processes системы, поддерживающие использование MMU 9X_os (например, Linux). В небольших / старых процессорах 9X_processes и микроконтроллерах и небольшой операционной 9X_threading системе RTOS (операционная система реального времени), такой как freeRTOS, нет 9X_threading поддержки MMU и, следовательно, нет процессов, а 9X_thread есть только потоки.

Потоки могут обращаться к памяти 9X_os друг друга, и они планируются операционной 9X_multi-threaded системой с чередованием, поэтому кажется, что 9X_os они работают параллельно (или с многоядерными 9X_process процессорами они действительно работают 9X_multithreading параллельно).

Процессы, с другой стороны, находятся 9X_operating-system в своей частной песочнице виртуальной памяти, предоставляемой 9X_multithreading и защищаемой MMU. Это удобно, потому что 9X_multithread позволяет:

1. не допустить сбоя всей системы в процессе с ошибками.
2. Обеспечение безопасности за счет скрытия данных других процессов и недоступен. Фактическая работа внутри процесса выполняется одним или несколькими потоками.

Я прочитал там почти все ответы, увы, будучи 9X_operating-system студентом, изучающим курс ОС, я не могу 9X_operating-systems полностью понять эти две концепции. Я имею 9X_threads в виду, что большинство парней читают из 9X_multithread некоторых книг по ОС различия, то есть потоки 9X_cross-threading могут получить доступ к глобальным переменным 9X_operating-systems в блоке транзакции, поскольку они используют 9X_operating-systems адресное пространство своего процесса. Тем 9X_thread не менее, возникает новый вопрос, почему 9X_multi-threaded существуют процессы, ведь мы уже знаем, что 9X_threads потоки более легкие по сравнению с процессами. Давайте 9X_multithreading взглянем на следующий пример, используя 9X_multithread изображение, взятое из one of the prior answers,

У нас есть 3 потока, работающих 9X_operating-system одновременно над текстовым документом, например 9X_process Libre Office. Первый проверяет орфографию, подчеркивая, если 9X_process слово написано с ошибкой. Второй берет и 9X_processes печатает буквы с клавиатуры. И последнее 9X_threads действительно сохраняет документ каждые 9X_process короткие промежутки времени, чтобы не потерять 9X_threads обработанный документ, если что-то пойдет 9X_cross-threading не так. В этом случае 3 потока не могут быть 3 процессами, поскольку они совместно используют общую память, которая является адресным пространством их процесса, и, таким образом, все имеют доступ к редактируемому документу. Итак, путь - это слово документ 9X_cross-threading вместе с двумя бульдозерами, которые являются 9X_cross-threading нитками, хотя один из них отсутствует на 9X_threading изображении.

1. По сути, поток - это часть процесса, но поток процесса не может работать.
2. Поток легковесен, тогда как процесс тяжелый.
3. обмен данными между процессами требует некоторого времени, тогда как потоку требуется меньше времени.
4. Потоки могут совместно использовать одну и ту же область памяти, тогда как процесс живет отдельно.

9X_threading

Процесс: выполняемая программа называется процессом

Поток: поток 9X_threading - это функция, которая выполняется с другой 9X_os частью программы на основе концепции «один 9X_os с другим», поэтому поток является частью 9X_threads процесса.

Лучший ответ, который я нашел до сих пор, - Michael Kerrisk's 'The Linux Programming Interface':

В 9X_multi-threaded современных реализациях UNIX каждый процесс 9X_cross-threading может иметь несколько потоков. исполнения. Один 9X_process из способов представить потоки - это набор 9X_multi-threaded процессов. которые используют одну и ту 9X_process же виртуальную память, а также ряд других атрибуты. Каждый 9X_threading поток выполняет один и тот же программный 9X_multithread код и разделяет та же область данных и 9X_threading куча. Однако у каждого потока есть свой 9X_threads стек. содержащие локальные переменные 9X_threads и информацию о связи вызовов функций. [LPI 9X_thread 2.12]

Эта книга - источник большой ясности; Джулия 9X_multi-threaded Эванс упомянула его помощь в выяснении того, как 9X_multi-threaded на самом деле работают группы Linux в this article.

При создании алгоритма на Python (интерпретируемом 9X_os языке), включающем многопоточность, я был 9X_processes удивлен, увидев, что время выполнения не 9X_processes было лучше по сравнению с последовательным 9X_thread алгоритмом, который я ранее построил. Чтобы 9X_process понять причину этого результата, я немного 9X_processes прочитал и считаю, что то, что я узнал, предлагает 9X_cross-threading интересный контекст, из которого можно лучше 9X_os понять различия между многопоточностью и 9X_threading многопроцессорностью.

Многоядерные системы 9X_processes могут выполнять несколько потоков выполнения, поэтому 9X_threading Python должен поддерживать многопоточность. Но 9X_multithreading Python - это не компилируемый язык, а интерпретируемый 9X_multi-threaded язык ¹ . Это означает, что программа должна 9X_threading быть интерпретирована для запуска, и интерпретатор 9X_multithreading не знает о программе до того, как она начнет 9X_multi-threaded выполнение. Однако он знает правила Python 9X_process и затем динамически применяет эти правила. Оптимизация 9X_operating-system в Python должна быть в основном оптимизацией 9X_threads самого интерпретатора, а не кода, который 9X_processes должен быть запущен. Это отличается от компилируемых 9X_multi-threaded языков, таких как C++, и имеет последствия 9X_process для многопоточности в Python. В частности, Python 9X_multithreading использует глобальную блокировку интерпретатора 9X_threading для управления многопоточностью.

С другой 9X_cross-threading стороны, скомпилированный язык является 9X_multi-threaded компилированным. Программа обрабатывается 9X_cross-threading «полностью», где сначала она интерпретируется 9X_thread в соответствии с ее синтаксическими определениями, затем 9X_processes отображается на независимое от языка промежуточное 9X_threads представление и, наконец, связывается с 9X_operating-systems исполняемым кодом. Этот процесс позволяет 9X_multithread максимально оптимизировать код, потому что 9X_threading все это доступно во время компиляции. Во 9X_multi-threaded время создания исполняемого файла определяются 9X_multi-threaded различные взаимодействия и взаимосвязи программы, и 9X_multithreading можно принимать надежные решения по оптимизации.

В 9X_multithreading современных средах интерпретатор Python 9X_processes должен разрешать многопоточность, и это 9X_os должно быть одновременно безопасным и эффективным. Здесь 9X_processes проявляется разница между интерпретируемым 9X_processes языком и компилируемым языком. Интерпретатор 9X_processes не должен нарушать внутренние общие данные 9X_threading из разных потоков, в то же время оптимизируя 9X_threads использование процессоров для вычислений.

Как 9X_threading было отмечено в предыдущих сообщениях, и 9X_processes процесс, и поток являются независимыми последовательными 9X_multithreading исполнениями, с основным отличием в том, что 9X_threading память распределяется между несколькими 9X_operating-systems потоками процесса, в то время как процессы 9X_process изолируют свои пространства памяти.

В Python 9X_operating-systems данные защищены от одновременного доступа 9X_processes разными потоками с помощью Global Interpreter 9X_threads Lock. Это требует, чтобы в любой программе 9X_process Python в любой момент мог выполняться только 9X_os один поток. С другой стороны, можно запускать 9X_processes несколько процессов, поскольку память для 9X_threads каждого процесса изолирована от любого другого 9X_threads процесса, и процессы могут выполняться на 9X_multithreading нескольких ядрах.

¹ Дональд Кнут дает хорошее 9X_multithread объяснение процедур интерпретации в книге 9X_operating-system "Искусство компьютерного программирования: фундаментальные 9X_threads алгоритмы".

Потоки в одном процессе совместно используют 9X_multithread память, но каждый поток имеет свой собственный 9X_cross-threading стек и регистры, а потоки хранят данные, относящиеся 9X_multithreading к потоку, в куче. Потоки никогда не выполняются 9X_threads независимо, поэтому обмен данными между 9X_processes потоками происходит намного быстрее, чем 9X_multi-threaded обмен данными между процессами.

Процессы 9X_multithreading никогда не используют одну и ту же память. Когда 9X_processes дочерний процесс создает, он дублирует место 9X_operating-system в памяти родительского процесса. Связь процессов 9X_processes осуществляется с помощью канала, общей памяти 9X_multi-threaded и синтаксического анализа сообщений. Переключение 9X_operating-systems контекста между потоками происходит очень 9X_multithreading медленно.

Пример 1. JVM работает в одном процессе, а 9X_os потоки в JVM совместно используют кучу, принадлежащую 9X_processes этому процессу. Вот почему несколько потоков 9X_process могут обращаться к одному и тому же объекту. Потоки 9X_threading совместно используют кучу и имеют собственное 9X_os пространство стека. Таким образом, вызов 9X_threads метода одним потоком и его локальные переменные 9X_threading сохраняются в потокобезопасности от других 9X_threading потоков. Но куча не является потокобезопасной 9X_operating-system и должна быть синхронизирована для обеспечения 9X_cross-threading безопасности потоков.

Рассматривайте процесс как единицу владения 9X_cross-threading или какие ресурсы необходимы для выполнения 9X_threading задачи. Процесс может иметь такие ресурсы, как 9X_threading объем памяти, определенный ввод / вывод, определенные 9X_process файлы, приоритет и т. Д.

Поток - это управляемая 9X_threads единица выполнения, или, говоря простыми 9X_multithread словами, ход выполнения последовательности 9X_processes инструкций

Различия между процессом и потоком приведены 9X_multi-threaded ниже:

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

Они почти такие же ... Но главное отличие 9X_multi-threaded в том, что поток легкий, а процесс тяжелый 9X_thread с точки зрения переключения контекста, рабочей 9X_processes нагрузки и т. д.

Я считаю, что самый простой способ понять 9X_threads разницу - это визуализировать, как потоки 9X_operating-systems и процессы выполняют свои задания.

Потоки работают 9X_threading параллельно в области общей памяти (процесса, который 9X_cross-threading их создал):

Thread 1 Thread 2 Thread 3 | | | | | | | | | | | | Complete Complete Complete 

Примечание. Вышеупомянутое можно интерпретировать как процесс (т. е. один процесс с 3 потоками)

Процессы выполняются параллельно и одновременно:

Process 1 Process 2 Process 3 | | | | | | | | | | | | | | | | | | Complete Complete Complete 

Процесс - Программа выполняется

Поток - поток 9X_thread - это выполнение наименьшей последовательности 9X_multi-threaded запрограммированных инструкций

Например, вы 9X_multi-threaded хотите вычислить умножение матриц, вы напишете 9X_operating-system программу для трех циклов внутри main и 9X_multithreading выполните ее. Теперь это ваш процесс.

Теперь 9X_multi-threaded ту же программу вы можете решить, создав 9X_threading потоки и назначив каждому потоку выполнение 9X_threading результата строки. Каждый поток будет работать 9X_operating-system независимо, а результат будет сохранен в 9X_thread массиве. Поскольку потоки используют одну 9X_cross-threading и ту же память внутри процесса.

В обоих случаях 9X_operating-system результат будет одинаковым.

на этом рисунке показана разница между процессом 9X_cross-threading и потоком