В чем разница между процессом и потоком?
В чем техническая разница между процессом и потоком?
У меня такое ощущение, что слово "процесс" используется слишком часто, и есть также аппаратные и программные потоки. Как насчет легких процессов в таких языках, как Erlang? Есть ли определенная причина использовать один термин над другим?
38 ответов
И процессы, и потоки являются независимыми последовательностями выполнения. Типичное отличие состоит в том, что потоки (одного и того же процесса) работают в общем пространстве памяти, а процессы - в отдельных пространствах памяти.
Я не уверен, на какие "аппаратные" и "программные" темы вы могли ссылаться. Потоки - это функция операционной среды, а не функция ЦП (хотя ЦП обычно выполняет операции, которые делают потоки эффективными).
Эрланг использует термин "процесс", потому что он не раскрывает модель многопрограммирования с общей памятью. Называя их "потоками", можно предположить, что они имеют общую память.
Процесс
Каждый процесс предоставляет ресурсы, необходимые для выполнения программы. Процесс имеет виртуальное адресное пространство, исполняемый код, открытые дескрипторы системных объектов, контекст безопасности, уникальный идентификатор процесса, переменные среды, класс приоритета, минимальный и максимальный размеры рабочего набора и, по крайней мере, один поток выполнения. Каждый процесс запускается с одного потока, часто называемого основным потоком, но может создавать дополнительные потоки из любого его потока.
Нить
Поток - это объект внутри процесса, который можно запланировать для выполнения. Все потоки процесса совместно используют его виртуальное адресное пространство и системные ресурсы. Кроме того, каждый поток поддерживает обработчики исключений, приоритет планирования, локальное хранилище потока, уникальный идентификатор потока и набор структур, которые система будет использовать для сохранения контекста потока до его планирования. Контекст потока включает в себя набор машинных регистров потока, стек ядра, блок среды потока и пользовательский стек в адресном пространстве процесса потока. Потоки также могут иметь собственный контекст безопасности, который можно использовать для олицетворения клиентов.
Нашел это на MSDN здесь:
О процессах и потоках
Microsoft Windows поддерживает вытесняющую многозадачность, которая создает эффект одновременного выполнения нескольких потоков из нескольких процессов. На многопроцессорном компьютере система может одновременно выполнять столько потоков, сколько имеется процессоров на компьютере.
Процесс:
- Исполняемый экземпляр программы называется процессом.
- Некоторые операционные системы используют термин "задача" для обозначения программы, которая выполняется.
- Процесс всегда сохраняется в основной памяти, также называемой основной памятью или оперативной памятью.
- Поэтому процесс называется активным субъектом. Исчезает, если машина перезагружена.
- Несколько процессов могут быть связаны с одной и той же программой.
- В многопроцессорной системе несколько процессов могут выполняться параллельно.
- В однопроцессорной системе, хотя истинный параллелизм не достигается, применяется алгоритм планирования процессов, и процессор планирует выполнять каждый процесс по одному, создавая иллюзию параллелизма.
- Пример: выполнение нескольких экземпляров программы "Калькулятор". Каждый из экземпляров называется процессом.
Нить:
- Поток - это подмножество процесса.
- Он называется "облегченным процессом", поскольку он похож на реальный процесс, но выполняется в контексте процесса и использует те же ресурсы, которые выделены для процесса ядром.
- Обычно процесс имеет только один поток управления - один набор машинных инструкций, выполняемых одновременно.
- Процесс также может состоять из нескольких потоков выполнения, которые выполняют инструкции одновременно.
- Несколько потоков управления могут использовать истинный параллелизм, возможный в многопроцессорных системах.
- В однопроцессорной системе применяется алгоритм планирования потоков, и процессор планирует запускать каждый поток по одному.
- Все потоки, работающие внутри процесса, имеют одинаковое адресное пространство, дескрипторы файлов, стек и другие атрибуты, связанные с процессом.
- Поскольку потоки процесса совместно используют одну и ту же память, синхронизация доступа к общим данным внутри процесса приобретает беспрецедентную важность.
Я позаимствовал вышеуказанную информацию из квеста знаний! блог
Сначала давайте посмотрим на теоретический аспект. Вам необходимо понять, что такое концептуальный процесс, чтобы понять разницу между процессом и потоком и тем, что между ними.
У нас есть следующее из раздела 2.2.2 Модель классической резьбы в современных операционных системах 3e от Tanenbaum:
Модель процесса основана на двух независимых концепциях: группировка ресурсов и выполнение. Иногда полезно разделить их; это где темы вступают....
Он продолжает:
Один из способов взглянуть на процесс состоит в том, что это способ объединить связанные ресурсы. Процесс имеет адресное пространство, содержащее текст программы и данные, а также другие ресурсы. Эти ресурсы могут включать открытые файлы, дочерние процессы, ожидающие тревоги, обработчики сигналов, учетную информацию и многое другое. Объединяя их в форме процесса, ими можно легче управлять. Другая концепция, которую имеет процесс, - это поток выполнения, обычно сокращаемый до простого потока. Поток имеет программный счетчик, который отслеживает, какую инструкцию выполнять дальше. Он имеет регистры, в которых хранятся текущие рабочие переменные. Он имеет стек, который содержит историю выполнения, с одним кадром для каждой вызванной процедуры, но еще не возвращенной из. Хотя поток должен выполняться в каком-то процессе, поток и его процесс являются разными концепциями и могут рассматриваться отдельно. Процессы используются для группировки ресурсов; потоки - это объекты, запланированные для выполнения на процессоре.
Далее он предоставляет следующую таблицу:
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 |
Давайте разберемся с проблемой аппаратного многопоточности. Классически, ЦП будет поддерживать один поток выполнения, поддерживая состояние потока с помощью одного счетчика программы и набора регистров. Но что произойдет, если пропадет кеш? Для извлечения данных из основной памяти требуется много времени, и пока это происходит, процессор просто бездействует. Таким образом, у кого-то возникла идея в основном иметь два набора состояний потока (ПК + регистры), чтобы другой поток (возможно, в том же процессе, может быть, в другом процессе) мог выполнить работу, пока другой поток ожидает в основной памяти. Существует несколько имен и реализаций этой концепции, таких как HyperThreading и одновременное многопоточность (для краткости SMT).
Теперь давайте посмотрим на сторону программного обеспечения. Существуют три основных способа реализации потоков на стороне программного обеспечения.
- Темы в пользовательском пространстве
- Потоки ядра
- Сочетание двух
Все, что вам нужно для реализации потоков, - это возможность сохранять состояние процессора и поддерживать несколько стеков, что во многих случаях может быть сделано в пространстве пользователя. Преимущество потоков в пользовательском пространстве заключается в супер-быстром переключении потоков, поскольку вам не нужно захватывать ядро и возможность планировать свои потоки так, как вам нравится. Самый большой недостаток - невозможность блокировать ввод-вывод (который блокировал бы весь процесс и все его пользовательские потоки), что является одной из основных причин, по которым мы используем потоки в первую очередь. Блокировка ввода / вывода с использованием потоков во многих случаях значительно упрощает разработку программы.
Преимущество потоков ядра состоит в том, что они могут использовать блокирующий ввод / вывод, в дополнение к тому, что все проблемы с планированием оставлены для ОС. Но каждое переключение потоков требует захвата в ядро, которое потенциально относительно медленное. Тем не менее, если вы переключаете потоки из-за заблокированного ввода-вывода, это на самом деле не проблема, поскольку операция ввода-вывода, вероятно, в любом случае застряла в ядре.
Другой подход состоит в том, чтобы объединить их с несколькими потоками ядра, каждый из которых имеет несколько пользовательских потоков.
Итак, возвращаясь к вашему вопросу о терминологии, вы можете увидеть, что процесс и поток выполнения - это две разные концепции, и выбор того, какой термин использовать, зависит от того, о чем вы говорите. Что касается термина "облегченный процесс", я лично не вижу в этом смысла, поскольку он на самом деле не передает происходящего так же, как и термин "нить исполнения".
Чтобы объяснить больше в отношении параллельного программирования
Процесс имеет автономную среду исполнения. Процесс обычно имеет полный, частный набор основных ресурсов времени выполнения; в частности, каждый процесс имеет свое собственное пространство памяти.
Внутри процесса существуют потоки - у каждого процесса есть хотя бы один. Потоки совместно используют ресурсы процесса, включая память и открытые файлы. Это способствует эффективному, но потенциально проблематичному общению.
Помнить среднего человека,
На вашем компьютере откройте Microsoft Word и веб-браузер. Мы называем эти два процесса.
В Microsoft Word вы вводите какую-то вещь, и она автоматически сохраняется. Теперь вы бы заметили, что редактирование и сохранение происходит параллельно - редактирование в одном потоке и сохранение в другом.
Приложение состоит из одного или нескольких процессов. Проще говоря, процесс - это исполняемая программа. Один или несколько потоков выполняются в контексте процесса. Поток - это базовая единица, которой операционная система выделяет процессорное время. Поток может выполнить любую часть кода процесса, включая части, выполняемые в данный момент другим потоком. Волокно - это единица выполнения, которая должна планироваться приложением вручную. Волокна работают в контексте потоков, которые их планируют.
Украдена отсюда.
Процесс - это набор кода, памяти, данных и других ресурсов. Поток - это последовательность кода, которая выполняется в рамках процесса. Вы можете (обычно) иметь несколько потоков, выполняющихся одновременно в одном и том же процессе.
Процесс:
- Процесс тяжелый процесс веса.
- Процесс представляет собой отдельную программу, которая имеет отдельную память, данные, ресурсы и т. Д.
- Процесс создается с использованием метода fork().
- Переключение контекста между процессами занимает много времени.
Пример:
Скажем, открываем любой браузер (Mozilla, Chrome, IE). В этот момент новый процесс начнет выполняться.
Потоки:
- Нити - это легковесные процессы. Нити связаны внутри процесса.
- Потоки имеют общую память, данные, ресурсы, файлы и т. Д.
- Потоки создаются методом clone().
- Переключение контекста между потоками не так много времени, как процесс.
Пример:
Открытие нескольких вкладок в браузере.
Пример реального процесса ипотока Это даст вам базовое представление о потоке и процессе 
Я заимствовал вышеупомянутую информацию от Ответа Скотта Лэнгхэма - спасибо
- Каждый процесс является потоком (основной поток).
- Но каждый поток не процесс. Это часть (сущность) процесса.
http://lkml.iu.edu/hypermail/linux/kernel/9608/0191.html
Линус Торвальдс (torvalds@cs.helsinki.fi)
Вт, 6 августа 1996 г. 12:47:31 +0300 (EET DST)
Сообщения отсортированы по: [дате][теме][теме][автору]
Следующее сообщение: Бернд П. Циллер: "Re: Упс в get_hash_table"
Предыдущее сообщение: Линус Торвальдс: "Re: I/O request ordering"
В понедельник, 5 августа 1996 года, Питер П. Эйзерлох написал:
Нам нужно четко понимать концепцию потоков. Слишком много людей, кажется, путают нить с процессом. Следующее обсуждение не отражает текущее состояние Linux, а скорее является попыткой остаться на высоком уровне обсуждения.
НЕТ!
Нет НИКАКОЙ причины думать, что "потоки" и "процессы" - это отдельные объекты. Вот как это традиционно делается, но я лично считаю, что думать об этом - большая ошибка. Единственная причина так думать - исторический багаж.
И потоки, и процессы - это всего лишь одно: "контекст выполнения". Попытка искусственно различать разные случаи просто самоограничена.
"Контекст исполнения", называемый здесь COE, - это просто конгломерат всего состояния этого COE. Это состояние включает в себя такие вещи, как состояние процессора (регистры и т. Д.), Состояние MMU (отображения страниц), состояние разрешений (uid, gid) и различные "состояния связи" (открытые файлы, обработчики сигналов и т. Д.). Традиционно различие между "потоком" и "процессом" было главным образом в том, что у потоков есть состояние ЦП (+ возможно, какое-то другое минимальное состояние), в то время как весь другой контекст происходит от процесса. Тем не менее, это только один из способов разделения общего состояния СЕ, и ничто не говорит о том, что это правильный способ сделать это. Ограничивать себя подобным образом просто глупо.
Linux думает об этом (и как я хочу, чтобы все работало) таково, что не существует такого понятия, как "процесс" или "поток". Существует только совокупность COE (так называемая "задача" в Linux). Различные COE могут обмениваться частями своего контекста друг с другом, и одно подмножество этого совместного использования является традиционной настройкой "потока"/"процесса", но это действительно следует рассматривать как ТОЛЬКО подмножество (это важное подмножество, но эта важность важна не от дизайна, а от стандартов: мы, разумеется, хотим запускать соответствующие потоки программы поверх Linux).
Короче говоря: НЕ проектируйте вокруг мышления потока / процесса. Ядро должно быть спроектировано с учетом мышления COE, и тогда библиотека pthreads может экспортировать ограниченный интерфейс pthreads пользователям, которые хотят использовать такой подход к COE.
Просто в качестве примера того, что становится возможным, когда вы думаете о COE, а не о потоке / процессе:
- Вы можете создать внешнюю программу "cd", что традиционно невозможно в UNIX и / или process/thread (глупый пример, но идея в том, что вы можете иметь такие "модули", которые не ограничиваются традиционной UNIX/ настройка потоков). Сделать:
Клон (CLONE_VM | CLONE_FS);
child: execve ("external-cd");
/ * execve() разъединит виртуальную машину, поэтому единственной причиной, по которой мы использовали CLONE_VM, было ускорение клонирования */
- Вы можете сделать "vfork()" естественным образом (это требует минимальной поддержки ядра, но эта поддержка идеально подходит для мышления CUA):
Клон (CLONE_VM);
ребенок: продолжать бежать, в конце концов, выполнить ()
мама: жди execve
- Вы можете сделать внешние "IO deamons":
клон (CLONE_FILES);
дочерний: открыть дескрипторы файлов и т. д
Мама: используйте ФД, ребенок открыл и вв.
Все вышеперечисленное работает, потому что вы не привязаны к нитью / процессуальному мышлению. Представьте, например, веб-сервер, где сценарии CGI выполняются как "потоки выполнения". Вы не можете сделать это с традиционными потоками, потому что традиционные потоки всегда должны совместно использовать все адресное пространство, поэтому вам нужно будет связать все, что вы когда-либо хотели сделать, на самом веб-сервере ("поток" не может работать другой исполняемый файл).
Думая об этом как о проблеме "контекста выполнения", ваши задачи теперь могут выбирать выполнение внешних программ (= отделение адресного пространства от родительского) и т. Д., Если они этого хотят, или они могут, например, делиться всем с родителем, кроме файловые дескрипторы (чтобы дочерние "потоки" могли открывать множество файлов без необходимости беспокоиться о них со стороны родителя: они автоматически закрываются при выходе из дочерней "ветки" и не используют fd в родительском файле),
Например, подумайте о резьбовом "inetd". Вы хотите использовать низкие издержки fork+exec, поэтому, используя способ Linux вместо "fork()", вы пишете многопоточный inetd, где каждый поток создается только с помощью CLONE_VM (разделяйте адресное пространство, но не делитесь файлом дескрипторы и т. д.). Затем ребенок может выполнить, если это была внешняя служба (например, rlogind), или, возможно, это была одна из внутренних служб inetd (echo, timeofday), и в этом случае он просто выполняет свою работу и завершает свою работу.
Вы не можете сделать это с "потоком"/"процессом".
Линус
И потоки, и процессы являются атомарными единицами распределения ресурсов ОС (т. Е. Существует модель параллелизма, описывающая, как процессорное время распределяется между ними, и модель владения другими ресурсами ОС). Есть разница в:
- Общие ресурсы (потоки разделяют память по определению, они не владеют ничем, кроме стека и локальных переменных; процессы также могут совместно использовать память, но для этого существует отдельный механизм, поддерживаемый ОС)
- Пространство выделения (пространство ядра для процессов и пространство пользователя для потоков)
Грег Хьюгилл (Greg Hewgill) был прав насчет значения слова "процесс" на языке Erlang, и здесь обсуждается, почему Erlang может делать процессы более легкими.
Попытка ответить на этот вопрос, касающийся мира Java.
Процесс - это выполнение программы, но поток - это отдельная последовательность выполнения внутри процесса. Процесс может содержать несколько потоков. Поток иногда называют облегченным процессом.
Например:
Пример 1: JVM работает в одном процессе, а потоки в JVM совместно используют кучу, принадлежащую этому процессу. Вот почему несколько потоков могут обращаться к одному и тому же объекту. Потоки разделяют кучу и имеют свое собственное пространство стека. Таким образом, вызов одного потока метода и его локальных переменных защищен потоком от других потоков. Но куча не является потокобезопасной и должна быть синхронизирована для безопасности потока.
Пример 2: Программа может быть не в состоянии рисовать картинки, читая нажатия клавиш. Программа должна уделять все внимание вводу с клавиатуры, а отсутствие возможности обрабатывать более одного события одновременно может привести к проблемам. Идеальным решением этой проблемы является одновременное выполнение двух или более разделов программы. Темы позволяют нам сделать это. Здесь Рисование изображения - это процесс, а нажатие клавиши - это подпроцесс (нить).
Процесс - это исполняемый экземпляр приложения. Что это значит? Ну, например, когда вы дважды щелкаете значок Microsoft Word, вы запускаете процесс, который запускает Word. Поток - это путь выполнения внутри процесса. Кроме того, процесс может содержать несколько потоков. Когда вы запускаете Word, операционная система создает процесс и начинает выполнять основной поток этого процесса.
Важно отметить, что поток может делать все, что может делать процесс. Но поскольку процесс может состоять из нескольких потоков, поток можно считать "легким" процессом. Таким образом, существенным отличием потока от процесса является работа, которую каждый выполняет для выполнения. Потоки используются для небольших задач, тогда как процессы используются для более "тяжелых" задач - в основном для выполнения приложений.
Другое различие между потоком и процессом состоит в том, что потоки в одном и том же процессе совместно используют одно и то же адресное пространство, а разные процессы - нет. Это позволяет потокам выполнять чтение и запись в одни и те же структуры данных и переменные, а также облегчает связь между потоками. Связь между процессами, также известная как IPC, или межпроцессное взаимодействие, является довольно сложной и ресурсоемкой.
Для тех, кто более удобен в обучении с помощью визуализации, вот удобная диаграмма, которую я создал, чтобы объяснить процессы и потоки.
Я использовал информацию из MSDN - О процессах и потоках
Пытаюсь ответить на него из представления ОС Linux Kernel
Программа становится процессом при запуске в память. Процесс имеет свое собственное адресное пространство, то есть имеет различные сегменты в памяти, такие как.text segement для хранения скомпилированного кода, .bss для хранения неинициализированных статических или глобальных переменных и т. Д. Каждый процесс будет иметь свой собственный программный счетчик и стек пользователя-spcae. Внутри ядра каждый процесс будет иметь свой собственный стек ядра (который отделен от стека пространства пользователя для вопросов безопасности) и структуру с именем task_struct который обычно абстрагируется как блок управления процессом, хранящий всю информацию, касающуюся процесса, такую как его приоритет, состояние (и многое другое). Процесс может иметь несколько потоков исполнения.
Что касается потоков, они находятся внутри процесса и совместно используют адресное пространство родительского процесса вместе с другими ресурсами, которые могут быть переданы во время создания потока, такими как ресурсы файловой системы, совместное использование ожидающих сигналов, совместное использование данных (переменных и инструкций), что делает потоки легкими и следовательно, позволяет более быстрое переключение контекста. Внутри ядра каждый поток имеет свой собственный стек ядра вместе с task_struct структура, которая определяет поток. Поэтому ядро рассматривает потоки одного и того же процесса как разные объекты и является планируемым самим по себе. Потоки в одном и том же процессе имеют общий идентификатор, называемый идентификатором группы потоков (tgid), также они имеют уникальный идентификатор, называемый идентификатором процесса (pid).
И процессы, и потоки являются независимыми последовательностями выполнения. Типичное отличие состоит в том, что потоки (одного и того же процесса) работают в общем пространстве памяти, а процессы - в отдельных пространствах памяти.
Процесс
Программа в исполнении. в нем есть текстовый раздел, т.е. программный код, текущая активность, представленная значением счетчика программы и содержимым регистра процессоров. Он также включает в себя стек процессов, который содержит временные данные (например, параметры функции, адреса возврата и локальные переменные) и раздел данных, который содержит глобальные переменные. Процесс также может включать в себя кучу, которая является памятью, которая динамически выделяется во время выполнения процесса.
Нить
Поток - это базовая единица загрузки процессора; он содержит идентификатор потока, счетчик программ, набор регистров и стек. он разделил с другими потоками, принадлежащими к тому же процессу, свой раздел кода, раздел данных и другие ресурсы операционной системы, такие как открытые файлы и сигналы.
- взято из операционной системы от Galvin
Лучший ответ
Процесс:
Процесс в основном программа в исполнении. Это активный субъект. Некоторые операционные системы используют термин "задача" для обозначения программы, которая выполняется. Процесс всегда сохраняется в основной памяти, также называемой основной памятью или оперативной памятью. Поэтому процесс называется активным субъектом. Исчезает, если машина перезагружена. Несколько процессов могут быть связаны с одной и той же программой. В многопроцессорной системе несколько процессов могут выполняться параллельно. В однопроцессорной системе, хотя истинный параллелизм не достигается, применяется алгоритм планирования процессов, и процессор планирует выполнять каждый процесс по одному, создавая иллюзию параллелизма. Пример: выполнение нескольких экземпляров программы "Калькулятор". Каждый из экземпляров называется процессом.
Нить:
Поток - это подмножество процесса. Он называется "облегченным процессом", поскольку он похож на реальный процесс, но выполняется в контексте процесса и использует те же ресурсы, которые выделены для процесса ядром. Обычно процесс имеет только один поток управления - один набор машинных инструкций, выполняемых одновременно. Процесс также может состоять из нескольких потоков выполнения, которые выполняют инструкции одновременно. Несколько потоков управления могут использовать истинный параллелизм, возможный в многопроцессорных системах. В однопроцессорной системе применяется алгоритм планирования потоков, и процессор планирует запускать каждый поток по одному. Все потоки, работающие внутри процесса, имеют одинаковое адресное пространство, дескрипторы файлов, стек и другие атрибуты, связанные с процессом. Поскольку потоки процесса совместно используют одну и ту же память, синхронизация доступа к совместно используемым данным внутри процесса приобретает беспрецедентную важность.
ref- https://practice.geeksforgeeks.org/problems/difference-between-process-and-thread
Разница между потоком и процессом?
Процесс - это исполняемый экземпляр приложения, а поток - это путь выполнения внутри процесса. Кроме того, процесс может содержать несколько потоков. Важно отметить, что поток может делать все, что может делать процесс. Но поскольку процесс может состоять из нескольких потоков, поток можно считать "легким" процессом. Таким образом, существенным отличием потока от процесса является работа, которую каждый выполняет для выполнения. Потоки используются для небольших задач, тогда как процессы используются для более "тяжелых" задач - в основном для выполнения приложений.
Другое различие между потоком и процессом состоит в том, что потоки в одном и том же процессе совместно используют одно и то же адресное пространство, а разные процессы - нет. Это позволяет потокам выполнять чтение и запись в одни и те же структуры данных и переменные, а также облегчает связь между потоками. Связь между процессами, также известная как IPC, или межпроцессное взаимодействие, является довольно сложной и ресурсоемкой.
Вот краткое изложение различий между потоками и процессами:
Потоки легче создавать, чем процессы, поскольку они не требуют отдельного адресного пространства.
Многопоточность требует тщательного программирования, поскольку потоки совместно используют структуры данных, которые должны изменяться только одним потоком за раз. В отличие от потоков, процессы не используют одно и то же адресное пространство.
Потоки считаются легкими, потому что они используют гораздо меньше ресурсов, чем процессы.
Процессы не зависят друг от друга. Потоки, поскольку они совместно используют одно и то же адресное пространство, являются взаимозависимыми, поэтому следует соблюдать осторожность, чтобы разные потоки не наступали друг на друга.
Это действительно еще один способ заявить #2 выше.Процесс может состоять из нескольких потоков.
- Поток выполняется в общей области памяти, но процесс выполняется в отдельной области памяти
- Нить - это легкий процесс, но процесс это тяжелый процесс.
- Поток - это подтип процесса.
С точки зрения интервьюера, есть в основном всего 3 основные вещи, которые я хочу услышать, кроме таких очевидных вещей, как процесс может иметь несколько потоков:
- Потоки разделяют одно и то же пространство памяти, что означает, что поток может получить доступ к памяти из памяти другого потока. Процессы нормально не могут.
- Ресурсы. Ресурсы (память, дескрипторы, сокеты и т. Д.) Освобождаются при завершении процесса, а не при завершении потока.
- Безопасность. Процесс имеет фиксированный токен безопасности. Поток, с другой стороны, может выдавать себя за других пользователей / токенов.
Если вы хотите больше, ответ Скотта Лэнгхэма в значительной степени охватывает все. Все это с точки зрения операционной системы. Разные языки могут реализовывать разные концепции, такие как задачи, легковесные потоки и т. Д., Но это всего лишь способы использования потоков (волокон в Windows). Нет аппаратных и программных потоков. Существуют аппаратные и программные исключения и прерывания или пользовательский режим и потоки ядра.
Следующее - то, что я получил от одной из статей о Проекте Кода. Я думаю, это объясняет все, что нужно четко.
Поток - это еще один механизм разделения рабочей нагрузки на отдельные потоки выполнения. Нить легче, чем процесс. Это означает, что он предлагает меньшую гибкость, чем полноценный процесс, но может быть запущен быстрее, поскольку операционная система требует меньше настроек. Когда программа состоит из двух или более потоков, все потоки разделяют одно пространство памяти. Процессы имеют отдельные адресные пространства. все потоки разделяют одну кучу. Но каждый поток имеет свой собственный стек.
Исходя из мира встраиваемых систем, я хотел бы добавить, что концепция процессов существует только в "больших" процессорах (процессорах длянастольных ПК, ARM Cortex A-9), которые имеют MMU (модуль управления памятью), и операционных системах, которые поддерживают использование MMU (такой как Linux). С маленькими / старыми процессорами и микроконтроллерами и небольшой операционной системой RTOS (операционная системареального времени), такой как freeRTOS, поддержка MMU отсутствует и, следовательно, нет процессов, а есть только потоки.
Потоки могут получать доступ к памяти друг друга, и они планируются ОС чередующимся образом, поэтому они, кажется, работают параллельно (или с многоядерными процессорами они действительно работают параллельно).
Процессы, с другой стороны, живут в своей изолированной песочнице виртуальной памяти, предоставляемой и защищаемой MMU. Это удобно, потому что позволяет:
- предотвращение сбоя всей системы при сбое.
- Поддержание безопасности, делая данные других процессов невидимыми и недоступными. Фактическая работа внутри процесса выполняется одним или несколькими потоками.
Я изучил почти все ответы там, увы, будучи студентом, изучающим курс ОС, в настоящее время я не могу полностью понять эти две концепции. Я имею в виду, что большинство парней читают из некоторых книг по ОС различия, то есть потоки имеют доступ к глобальным переменным в единице транзакции, поскольку они используют адресное пространство своего процесса. Тем не менее, вновь возникает вопрос, почему существуют процессы, мы знаем, что потоки являются более легкими по сравнению с процессами. Давайте посмотрим на следующий пример, используя изображение, взятое из одного из предыдущих ответов:
У нас есть 3 темы, работающие одновременно над одним документом, например, Libre Office. Первый выполняет проверку орфографии, подчеркивая, что слово написано с ошибкой. Второй берет и печатает буквы с клавиатуры. И последний действительно сохраняет документ через каждые короткие промежутки времени, чтобы не потерять работающий документ, если что-то пойдет не так. В этом случае 3 потока не могут быть 3 процессами, поскольку они совместно используют общую память, которая является адресным пространством их процесса, и, таким образом, все имеют доступ к редактируемому документу. Итак, дорога - это документ Word вместе с двумя бульдозерами, которые являются нитями, хотя в одном из них отсутствует изображение.
Процесс: исполняемая программа называется процессом
Поток: Поток - это функциональность, которая выполняется с другой частью программы на основе концепции "один с другим", поэтому поток является частью процесса.
- По сути, поток является частью процесса, без которого поток процесса не сможет работать.
- Нить легкая, а процесс тяжелый.
- связь между процессом требует некоторого времени, тогда как потоку требуется меньше времени.
- Потоки могут совместно использовать одну и ту же область памяти, в то время как процесс находится в отдельности.
Лучшее короткое определение, которое я видел до сих пор, взято из "Интерфейса программирования Linux" Майкла Керриска:
В современных реализациях UNIX каждый процесс может иметь несколько потоков выполнения. Одним из способов представления потоков является набор процессов, которые совместно используют одну и ту же виртуальную память, а также ряд других атрибутов. Каждый поток выполняет один и тот же программный код и использует одну и ту же область данных и кучу. Однако каждый поток имеет свой собственный стек, содержащий локальные переменные и информацию о связи вызовов функций. [LPI 2.12]
При создании алгоритма в Python (интерпретируемый язык), который включал многопоточность, я был удивлен, увидев, что время выполнения было не лучше, чем по сравнению с последовательным алгоритмом, который я ранее построил. Чтобы понять причину этого результата, я немного прочитал и считаю, что то, что я узнал, предлагает интересный контекст, из которого можно лучше понять различия между многопоточностью и многопроцессорностью.
Многоядерные системы могут осуществлять несколько потоков выполнения, поэтому Python должен поддерживать многопоточность. Но Python - это не скомпилированный язык, а интерпретируемый язык1. Это означает, что программа должна интерпретироваться для запуска, и интерпретатор не знает о программе до того, как она начнет выполняться. Однако он знает правила Python, и затем он динамически применяет эти правила. Оптимизация в Python должна быть главным образом оптимизацией самого интерпретатора, а не кода, который должен быть запущен. Это отличается от скомпилированных языков, таких как C++, и имеет последствия для многопоточности в Python. В частности, Python использует глобальную блокировку интерпретатора для управления многопоточностью.
С другой стороны, скомпилированный язык, ну, в общем, скомпилирован. Программа обрабатывается "полностью", где сначала она интерпретируется в соответствии с ее синтаксическими определениями, затем отображается в независимое от языка промежуточное представление и, наконец, связывается в исполняемый код. Этот процесс позволяет высоко оптимизировать код, поскольку он все доступен во время компиляции. Различные программные взаимодействия и отношения определяются во время создания исполняемого файла, и могут быть приняты надежные решения по оптимизации.
В современных средах интерпретатор Python должен разрешать многопоточность, и это должно быть безопасным и эффективным. В этом и заключается разница между интерпретируемым языком и компилируемым языком. Интерпретатор не должен мешать внутреннему обмену данными из разных потоков, одновременно оптимизируя использование процессоров для вычислений.
Как было отмечено в предыдущих статьях, и процесс, и поток являются независимыми последовательными выполнениями, с основным отличием в том, что память распределяется между несколькими потоками процесса, в то время как процессы изолируют свои области памяти.
В Python данные защищены от одновременного доступа разными потоками с помощью Global Interpreter Lock. Это требует, чтобы в любой программе на Python в каждый момент времени мог выполняться только один поток. С другой стороны, можно запускать несколько процессов, так как память для каждого процесса изолирована от любого другого процесса, и процессы могут работать на нескольких ядрах.
1 Дональд Кнут имеет хорошее объяснение интерпретирующих процедур в "Искусстве компьютерного программирования: фундаментальные алгоритмы".
Потоки в одном и том же процессе совместно используют память, но каждый поток имеет свой собственный стек и регистры, а потоки хранят специфичные для потока данные в куче. Потоки никогда не выполняются независимо, поэтому взаимодействие между потоками происходит намного быстрее по сравнению с обменом между процессами.
Процессы никогда не разделяют одну и ту же память. Когда дочерний процесс создает, он дублирует область памяти родительского процесса. Обмен данными между процессами осуществляется с использованием канала, разделяемой памяти и анализа сообщений. Переключение контекста между потоками происходит очень медленно.
Они почти одинаковы... Но ключевое отличие в том, что поток является легковесным, а процесс - тяжелым с точки зрения переключения контекста, рабочей нагрузки и так далее.