Яка різниця між процесом і потоком?

У чому полягає технічна різниця між процесом і потоком?

Я відчуваю, що таке слово, як "процес", перевтомлюється, а також є апаратні та програмні потоки. Як щодо легких процесів на таких мовах, як Ерланг ? Чи є певна причина використовувати один термін над іншим?

І процеси, і потоки є незалежними послідовностями виконання. Типова відмінність полягає в тому, що потоки (одного і того ж процесу) працюють у спільному просторі пам'яті, тоді як процеси працюють в окремих просторах пам'яті.

Я не впевнений, про які "апаратні" та "програмні" теми ви можете мати на увазі. Нитки - це особливість операційного середовища, а не функція процесора (хоча процесор, як правило, має операції, які роблять потоки ефективними).

Ерланг використовує термін "процес", оскільки він не відкриває модель багатопрограмування спільної пам'яті. Називати їх "нитками" означало б, що вони мають спільну пам'ять.

Процес
Кожен процес забезпечує ресурси, необхідні для виконання програми. Процес має віртуальний адресний простір, виконуваний код, відкриті ручки до системних об'єктів, контекст безпеки, унікальний ідентифікатор процесу, змінні середовища, клас пріоритету, мінімальний та максимальний розміри робочого набору та принаймні один потік виконання. Кожен процес починається з однієї нитки, яку часто називають первинною ниткою, але може створювати додаткові потоки з будь-яких її потоків.

Нитка
Нитка - це сутність у процесі, який можна запланувати для виконання. Усі потоки процесу поділяють його віртуальний адресний простір та системні ресурси. Крім того, кожен потік підтримує обробники винятків, пріоритет планування, локальне зберігання потоків, унікальний ідентифікатор потоку та набір структур, які система використовуватиме для збереження контексту потоку до його планування. Контекст потоку включає набір потоків машинних регістрів, стек ядра, блок середовища потоку і стек користувача в адресному просторі процесу потоку. Нитки також можуть мати власний контекст безпеки, який можна використовувати для представлення себе за клієнтів.

Ця інформація була знайдена в документах Microsoft Docs тут: Про процеси та нитки

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 та Simulta Multithreading (короткий SMT).

Тепер давайте розглянемо сторону програмного забезпечення. В основному є три способи реалізації потоків на стороні програмного забезпечення.

1. Нитки простору користувача
2. Нитки ядра
3. Поєднання двох

Все, що вам потрібно для реалізації потоків, - це можливість зберігати стан процесора та підтримувати декілька стеків, що в багатьох випадках можна зробити в просторі користувача. Перевага потоків користувальницького простору полягає в надшвидкій комутації потоків, оскільки вам не доведеться потрапляти в ядро ​​та можливість планувати свої потоки так, як вам подобається. Найбільшим недоліком є ​​неможливість блокувати введення / виведення (що блокувало б увесь процес і всі його потоки користувача), що є однією з головних причин, що ми використовуємо теми в першу чергу. Блокування вводу / виводу за допомогою потоків значно спрощує розробку програми у багатьох випадках.

Нитки ядра мають перевагу в тому, що вони можуть використовувати блокуючі введення / виведення, а також залишати всі проблеми з плануванням в ОС. Але кожен перемикач потоку вимагає захоплення ядра, що потенційно є відносно повільним. Однак якщо ви перемикаєте потоки через заблокований введення / вивід, це насправді не проблема, оскільки операція вводу / виводу, ймовірно, вже захопила вас у ядро.

Інший підхід полягає в поєднанні двох, з декількома потоками ядра, кожна з яких має кілька потоків користувачів.

Повертаючись до свого питання про термінологію, ви можете бачити, що процес і нитка виконання - це два різних поняття, і ваш вибір того, який термін використовувати, залежить від того, про що ви говорите. Щодо терміна "процес легкої ваги", я особисто не бачу сенсу в цьому, оскільки він насправді не передає, що відбувається, а також термін "нитка виконання".

Щоб пояснити більше стосовно одночасного програмування

1. У процесі є автономне середовище виконання. Процес, як правило, має повний, приватний набір основних ресурсів виконання; зокрема, кожен процес має власний простір пам’яті.

2. Нитки існують в процесі - кожен процес має принаймні один. Нитки діляться ресурсами процесу, включаючи пам'ять та відкриті файли. Це сприяє ефективному, але потенційно проблемному спілкуванню.

Маючи на увазі середню людину,

На комп’ютері відкрийте Microsoft Word та веб-браузер. Ми називаємо ці два процеси .

У слові Microsoft ви вводите якусь річ, і вона автоматично зберігається. Тепер ви могли б спостерігати, як редагування та збереження відбувається паралельно - редагування на одному потоці та збереження на іншому потоці.

Додаток складається з одного або декількох процесів. Процес, простіше кажучи, - це програма, що виконується. Одна або кілька потоків запускаються в контексті процесу. Потік - це основний блок, на який операційна система виділяє час процесора. Потік може виконати будь-яку частину коду процесу, включаючи частини, які в даний час виконуються іншим потоком. Волокно - це одиниця виконання, яка повинна бути вручну запланована програмою. Волокна запускаються в контексті потоків, які їх планують.

Вкрадено звідси .

Процес - це набір коду, пам'яті, даних та інших ресурсів. Нитка - це послідовність коду, яка виконується в межах процесу. Ви можете (як правило) мати кілька потоків, що виконуються одночасно в межах одного процесу.

Приклад реального світу для Process and Thread Це дасть вам основне уявлення про нитку та процес

Я запозичив вищенаведену інформацію з відповіді Скотта Лангема - дякую

Процес:

1. Процес - важкий процес ваги.
2. Процес - це окрема програма, яка має окрему пам'ять, дані, ресурси тощо.
3. Процес створюється за допомогою методу fork ().
4. Контекстний перемикач між процесом займає багато часу.
   

Приклад:
Скажімо, відкривши будь-який браузер (mozilla, Chrome, IE). З цього моменту почнеться новий процес.

Нитки:

1. Нитки - це легкі ваги. Нитки в'язані всередині процесу.
2. Нитки мають спільну пам'ять, дані, ресурси, файли тощо.
3. Нитки створюються за допомогою методу clone ().
4. Контекстний перемикач між потоками не займає багато часу як процес.
   

Приклад:
Відкриття декількох вкладок у браузері.

• Кожен процес - це нитка (первинна нитка).
• Але кожна нитка - це не процес. Це частина (сутність) процесу.

І потоки, і процеси - це атомні одиниці розподілу ресурсів ОС (тобто існує паралельна модель, що описує, як розподіляється між ними час процесора, і модель володіння іншими ресурсами ОС). Існує різниця в:

• Спільні ресурси (потоки діляться пам’яттю за визначенням, їм не належить нічого, крім стека та локальних змінних; процеси також можуть спільно використовувати пам'ять, але для цього існує окремий механізм, який підтримується ОС)
• Простір розподілу (простір ядра для процесів проти простору користувача для потоків)

Вище Грег Хьюгілл був правильним щодо значення Ерланга слова "процес", і тут обговорюється питання, чому Ерланг міг робити процеси легкими.

І процеси, і потоки є незалежними послідовностями виконання. Типова відмінність полягає в тому, що потоки (одного і того ж процесу) працюють у спільному просторі пам'яті, тоді як процеси працюють в окремих просторах пам'яті.

Процес

Це програма у виконанні. У ньому є розділ тексту, тобто код програми, поточна активність, представлена ​​значенням лічильника програм та вмістом реєстру процесорів. Він також включає стек процесів, який містить тимчасові дані (такі як параметри функції, адресовані повернення та локальні змінні) та розділ даних, який містить глобальні змінні. Процес також може включати купу, яка є пам'яттю, яка динамічно розподіляється під час виконання процесу.

Нитка

Потік - це основна одиниця використання процесора; він містить ідентифікатор потоку, лічильник програми, набір реєстру та стек. він поділився з іншими потоками, що належать до того самого процесу, своїм кодовим розділом, розділом даних та іншими ресурсами операційної системи, такими як відкриті файли та сигнали.

- взято з операційної системи Галвіном

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: замовлення вводу / виводу"

У понеділок, 5 серпня 1996 р., Петро П. Ейзерлох написав:

Нам потрібно дотримуватися чіткого поняття ниток. Занадто багато людей, схоже, плутають нитку з процесом. Наступне обговорення не відображає поточний стан linux, а скоріше є спробою залишитися на дискусії високого рівня.

НІ!

Немає підстав думати, що "потоки" та "процеси" - це окремі сутності. Ось як це робиться традиційно, але я особисто вважаю, що головна помилка мислити саме так. Єдина причина вважати це - історичний багаж.

І потоки, і процеси - це лише одне: "контекст виконання". Спроба штучно розрізнити різні випадки - це лише обмежує себе.

"Контекст виконання", який називається РЄ, - це лише конгломерат всього стану цієї РЄ. Цей стан включає такі речі, як стан процесора (регістри тощо), стан MMU (відображення сторінок), стан дозволу (uid, gid) та різні "стани зв'язку" (відкриті файли, обробники сигналів тощо). Традиційно різниця між "потоком" і "процесом" полягала в основному в тому, що потоки мають стан процесора (+ можливо, якийсь інший мінімальний стан), тоді як увесь інший контекст походить від процесу. Однак це лише одне способів розподілу загального стану РЄ, і немає нічого, що говорить про те, що це правильно зробити. Обмежувати себе таким образом просто нерозумно.

Те, як Linux думає про це (і те, як я хочу, щоб справи працювали), полягає в тому, що не існує такого поняття, як "процес" чи "потік". Існує лише сукупність COE (Linux називається "завдання"). Різні РЄ можуть ділитися частинами свого контексту між собою та одним підмножиною цього спільного доступу - це традиційна настройка «потоку» / «процесу», але це дійсно слід розглядати як ТІЛЬКІ підмножини (це важливий підмножина, але ця важливість приходить не від дизайну, а від стандартів: ми явно хочемо запускати програми, що відповідають стандартам, і поверх Linux).

Коротше кажучи: НЕ розробляйте навколо нитки / процесу мислення. Ядро повинно бути розроблене навколо способу мислення COE, а потім бібліотеки pthreads може експортувати обмежений інтерфейс pthreads для користувачів, які хочуть використовувати такий спосіб перегляду COE.

Як приклад того, що стає можливим, коли ви думаєте, що COE на відміну від потоку / процесу:

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

клон (CLONE_VM | CLONE_FS);

дитина: execve ("зовнішній-cd");

/ * "execve ()" роз'єднає VM, тому єдиною причиною, за якою ми використовували CLONE_VM, було швидше зробити акт клонування * /

• Ви можете зробити "vfork ()" природно (це вимагає мінімальної підтримки ядра, але ця ідеально відповідає способу мислення CUA):

клон (CLONE_VM);

дитина: продовжуйте бігати, врешті виконайте ()

мати: чекай execve

• ви можете виконувати зовнішні "IO deamons":

клон (CLONE_FILES);

дитина: відкриті дескриптори файлів тощо

мати: використовуйте фд, дитина відкрила і vv.

Все вищезазначене працює тому, що ви не прив'язані до нитки / процесу мислення. Придумайте, наприклад, веб-сервер, де сценарії CGI виконуються як "потоки виконання". Ви не можете цього зробити з традиційними потоками, тому що традиційні потоки завжди мають розділяти весь адресний простір, тож вам доведеться зв’язати все, що коли-небудь хотіли зробити на самому веб-сервері ("нитка" не може працювати інший виконуваний файл).

Думаючи про це , як «контексті виконання» проблеми , а ваші завдання тепер можуть вибрати для виконання зовнішніх програм (= відокремити адресний простір від батька) і т.д. , якщо вони хочуть, або вони можуть, наприклад , ділити все з батьком , за винятком для дескриптори файлів (так що суб-"потоки" можуть відкривати безліч файлів, не вимагаючи того, щоб батьки про них турбувалися: вони закриваються автоматично, коли під-"потік" виходить, і він не використовує файли fd's у батьківській) .

Придумайте, наприклад, різьбовий "inetd". Ви хочете з низькими накладними fork + exec, тому за допомогою способу Linux ви можете замість того, щоб використовувати "fork ()", ви пишете багатопотоковий inetd, де кожен потік створюється просто CLONE_VM (спільний адресний простір, але не діліться файлом дескриптори тощо). Тоді дитина може виконати, якщо це була зовнішня послуга (наприклад, rlogind), або, можливо, це була одна із внутрішніх служб inetd (ехо, timeofday), і в цьому випадку вона просто робить це і спрацьовує.

Ви не можете зробити це за допомогою "thread" / "process".

Лінус

Спроба відповісти на це з перегляду ОС ОС ядра Linux

Програма стає процесом при запуску в пам'ять. Процес має власний адресний простір, що означає різні сегменти в пам'яті, такі як .textсегмент для зберігання компільованого коду, .bssдля зберігання неініціалізованих статичних або глобальних змінних тощо.
Кожен процес має власний лічильник програм та стек простору користувача .

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

Переходячи до потоків, вони перебувають всередині процесу та діляться адресним простором батьківського процесу разом з іншими ресурсами, які можуть передаватися під час створення потоку, такими як ресурси файлової системи, обмін сигналами, що очікують, обмін даними (змінні та інструкції), тому роблячи потоки легкими та отже, дозволяє швидше переключатися на контекст.

Всередині ядра кожен потік має власний стек ядра разом зі task_structструктурою, яка визначає нитку. Тому ядро ​​переглядає потоки того самого процесу, що й різні об'єкти, і планується в собі. Нитки в тому ж процесі мають спільний ідентифікатор, який називається ідентифікатором групи потоків ( tgid), також вони мають унікальний ідентифікатор, який називається id процесу ( pid).

Намагаюся відповісти на це питання, що стосується світу Java.

Процес - це виконання програми, але потік - це єдина послідовність виконання в процесі. Процес може містити кілька потоків. Нитку іноді називають легким процесом .

Наприклад:

Приклад 1: JVM працює в одному процесі, а потоки в JVM ділять купу, що належить до цього процесу. Ось чому декілька потоків можуть отримати доступ до одного об’єкта. Нитки розділяють купу і мають власний простір для стеків. Ось як виклик методу однієї нитки методу та його локальних змінних захищає потоки в безпеці від інших потоків. Але купа не є безпечною для ниток і повинна бути синхронізована для безпеки потоку.

Приклад 2: Програма може не мати можливості малювати зображення, читаючи натискання клавіш. Програма повинна повністю приділяти увагу клавіатурі, а відсутність можливості керувати кількома подіями одночасно призведе до проблем. Ідеальним рішенням цієї проблеми є безперебійне виконання двох або більше розділів програми одночасно. Нитки дозволяють нам це зробити. Тут Нанесення малюнка - це процес, і читання натискання клавіш - це підпроцес (потік).

Різниця між ниткою та процесом?

Процес є виконавчим екземпляром програми, а потік - це шлях виконання в процесі. Крім того, процес може містити кілька потоків. Важливо зазначити, що нитка може робити все, що процес може зробити. Але оскільки процес може складатися з декількох потоків, нитку можна вважати «легким» процесом. Таким чином, суттєвою відмінністю між потоком і процесом є робота, яку використовують для виконання кожної з них. Нитки використовуються для невеликих завдань, тоді як процеси використовуються для більш важких завдань - в основному виконання програм.

Інша відмінність між потоком і процесом полягає в тому, що потоки в межах одного процесу мають однаковий адресний простір, тоді як різні процеси не мають. Це дозволяє потокам читати і записувати в однакові структури даних і змінних, а також полегшує зв'язок між потоками. Комунікація між процесами - також відома як IPC, або міжпроцесовий зв'язок - досить складна і ресурсомістка.

Ось підсумок відмінностей між потоками та процесами:

1. Нитки легше створити, ніж процеси, оскільки вони не потребують окремого адресного простору.

2. Багатопотокове читання вимагає ретельного програмування, оскільки потоки обмінюються структурами даних, які повинні бути змінені лише одним потоком за один раз. На відміну від потоків, процеси не мають однакового простору адреси.

3. Нитки вважаються легкими, оскільки вони використовують набагато менше ресурсів, ніж процеси.

4. Процеси не залежать один від одного. Нитки, оскільки вони мають однаковий адресний простір, є взаємозалежними, тому слід бути обережними, щоб різні нитки не наступали один на одного.
   Це дійсно інший спосіб заявити №2 вище.

5. Процес може складатися з декількох потоків.

Далі - це те, що я отримав з однієї зі статей про проект «Код» . Я думаю, це пояснює все необхідне чітко.

Нитка - це ще один механізм розподілу навантаження на окремі потоки виконання. Нитка легша за вагу, ніж процес. Це означає, що він пропонує меншу гнучкість, ніж процес повного видуву, але його можна ініціювати швидше, тому що для налаштування Операційної системи менше. Коли програма складається з двох або більше потоків, всі потоки розділяють один простір пам'яті. Процесам надаються окремі адресні простори. всі нитки поділяють одну купу. Але кожному потоку надається свій стек.

Процес:

Процес - це в основному програма у виконанні. Це активна сутність. Деякі операційні системи використовують термін "завдання" для позначення програми, яка виконується. Процес завжди зберігається в основній пам'яті, що також називається первинною пам'яттю або пам'яттю з випадковим доступом. Тому процес називають активним об'єктом. Він зникає при перезавантаженні машини. З однією і тією ж програмою може бути пов'язано кілька процесів. У багатопроцесорній системі паралельно можуть виконуватися кілька процесів. У однопроцесорній системі, хоча справжній паралелізм не досягнуто, застосовується алгоритм планування процесу, і процесор планується виконувати кожен процес по одному, створюючи ілюзію одночасності. Приклад: Виконання декількох примірників програми "Калькулятор". Кожен з екземплярів називається процесом.

Нитка:

Нитка - це підмножина процесу. Його називають "легким процесом", оскільки він подібний до реального процесу, але виконується в контексті процесу і ділиться тими ж ресурсами, які виділяються ядром для цього процесу. Зазвичай процес має лише один потік управління - один набір машинних інструкцій, що виконуються за один раз. Процес також може складатися з декількох потоків виконання, які виконують інструкції одночасно. Кілька ниток управління можуть використовувати справжній паралелізм, можливий у багатопроцесорних системах. У однопроцесорній системі застосовується алгоритм планування потоків, і планується, щоб процесор запускав кожен потік по одному. Усі потоки, що працюють в процесі, мають однаковий адресний простір, дескриптори файлів, стек та інші атрибути, пов'язані з процесом. Оскільки потоки процесу мають однакову пам’ять,

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

З точки зору інтерв'юера, я в основному лише 3 основні речі, які я хочу почути, окрім очевидних речей, таких як процес, може мати декілька потоків:

1. Нитки поділяють той самий простір пам'яті, що означає, що потік може отримати доступ до пам'яті з потокової пам'яті інших. Процеси нормально не можуть.
2. Ресурси. Ресурси (пам'ять, ручки, сокети тощо) вивільняються під час завершення процесу, а не припинення потоку.
3. Безпека. Процес має фіксований маркер безпеки. З іншого боку, потік може представляти різних користувачів / жетонів.

Якщо ви хочете більше, відповідь Скотта Ленґема в значній мірі охоплює все. Все це з точки зору операційної системи. Різні мови можуть реалізовувати різні концепції, як-от завдання, світло-нитки і т. Д., Але це лише способи використання ниток (з волокон у Windows). Немає апаратних та програмних потоків. Існує апаратні і програмні виключення і переривання , або призначений для користувача режим і ядро нитка .

1. Потік працює у спільному просторі пам'яті, але процес працює в окремому просторі пам'яті
2. Нитка - це легкий процес, але процес - це важкий процес.
3. Нитка - це підтип процесу.

Для тих, кому зручніше вчитись шляхом візуалізації, ось зручна діаграма, яку я створив для пояснення процесу та теми.
Я використовував інформацію з MSDN - Про процеси та нитки

Походячи з вбудованого світу, я хотів би додати, що концепція процесів існує лише у "великих" процесорах ( настільні процесори, ARM Cortex A-9 ), які мають MMU (блок управління пам'яттю), і операційних системах, що підтримують використання MMU ( наприклад, Linux ). З маленькими / старими процесорами та мікроконтролерами та малою операційною системою RTOS (операційна система в режимі реального часу ), такою як freeRTOS, немає підтримки MMU і, отже, немає процесів, а лише потоки.

Нитки можуть отримати доступ до пам’яті один одного, і вони плануються ОС перемежованим чином, так що вони, здається, працюють паралельно (або з багатоядерними вони дійсно працюють паралельно).

Процеси , з іншого боку, живуть у своїй приватній пісочниці віртуальної пам’яті, наданої та охороняється MMU. Це зручно, оскільки це дозволяє:

1. запобігання баггі-процесу від збою всієї системи.
2. Підтримка безпеки, роблячи дані інших процесів невидимими і недосяжними. Про фактичну роботу всередині процесу опікується однією або декількома нитками.

1. В основному, потік є частиною процесу, без потоку процесу він не міг би працювати.
2. Нитка легка, тоді як процес важкий.
3. комунікація між процесом вимагає певного часу, тоді як потоці потрібно менше часу.
4. Нитки можуть мати однакову область пам’яті, тоді як процес проходить окремо.

Процес : програма, що виконується, відома як процес

Thread : Thread - це функція, яка виконується з іншою частиною програми на основі поняття "один з іншим", тому нитка є частиною процесу.

Я начитався майже всіх відповідей там, на жаль, як студент, який зараз курсує ОС, не можу досконало зрозуміти ці два поняття. Я маю на увазі, що більшість хлопців читають з деяких книг ОС різниці, тобто потоки можуть отримати доступ до глобальних змінних у блоці транзакцій, оскільки вони використовують адресний простір свого процесу. Але знову виникає запитання, чому існують процеси, маючи на увазі, що ми знаємо, що нитки є більш легкими по відношенню до процесів. Давайте розглянемо наступний приклад, використовуючи зображення, витягнуте з одного з попередніх відповідей ,

У нас одразу 3 теми працюють над текстовим документом, наприклад Libre Office . Перший робить перевірку орфографії, підкреслюючи, чи слово неправильне написання. Другий бере і друкує букви з клавіатури. І останнє зберігає документ за кожен короткий час, щоб не втратити документ, на якому працювали, якщо щось пішло не так. У цьому випадку 3 потоку не можуть бути 3-ма процесами, оскільки вони поділяють загальну пам'ять, що є адресним простором їх процесу, і тому всі мають доступ до редагуваного документа. Отже, дорога - це слово-документ разом із двома бульдозерами, які є нитками, хоча один із них не має зображення.

Під час побудови алгоритму в Python (інтерпретована мова), який включає в себе багатопотоковість, я був здивований, побачивши, що час виконання не був кращим порівняно з послідовно створеним раніше алгоритмом. Прагнучи зрозуміти причину цього результату, я прочитав читання, і повір, що я дізнався, пропонує цікавий контекст, з якого можна краще зрозуміти відмінності між багатопотоковою та багатопроцесовою процесами.

Багатоядерні системи можуть здійснювати кілька потоків виконання, і тому Python повинен підтримувати багатопотоковість. Але Python не є компільованою мовою, а натомість є інтерпретованою мовою ¹ . Це означає, що програма повинна бути інтерпретована для запуску, а інтерпретатор не знає про програму до початку її виконання. Однак він знає, що це правила Python, і він динамічно застосовує ці правила. Оптимізація в Python повинна в основному бути оптимізацією самого інтерпретатора, а не кодом, який слід запускати. Це на відміну від компільованих мов, таких як C ++, і має наслідки для багатопотокової роботи в Python. Зокрема, Python використовує Global Interpreter Lock для управління багатопотоковою нарізкою.

З іншого боку, складена мова - це добре. Програма обробляється "цілком", де спочатку інтерпретується відповідно до її синтаксичних визначень, потім відображається на мовному агностичному проміжному поданні та, нарешті, зв'язується з виконуваним кодом. Цей процес дозволяє сильно оптимізувати код, оскільки він доступний на момент складання. Різні програмні взаємодії та взаємозв'язки визначаються під час створення виконавчого файлу та прийняття надійних рішень щодо оптимізації.

У сучасних умовах перекладач Python повинен дозволити багатопотокове навантаження, і це повинно бути безпечним та ефективним. Тут відображається різниця між інтерпретованою мовою та мовою, що складена. Інтерпретатор не повинен перешкоджати внутрішнім поділам даних з різних потоків, одночасно оптимізуючи використання процесорів для обчислень.

Як було зазначено в попередніх публікаціях, і процес, і потік є незалежними послідовними виконаннями, головна відмінність полягає в тому, що пам'ять поділяється на декілька потоків процесу, тоді як процеси ізолюють простір пам’яті.

У Python дані захищені від одночасного доступу різними потоками за допомогою Global Interpreter Lock. Це вимагає, щоб у будь-якій програмі Python в будь-який час може бути виконаний лише один потік. З іншого боку, можна запустити кілька процесів, оскільки пам'ять для кожного процесу є ізольованою від будь-якого іншого процесу, і процеси можуть працювати на декількох ядрах.

¹ Дональд Кнут має чітке пояснення інтерпретаційних процедур у «Мистецтві комп’ютерного програмування: фундаментальні алгоритми».

Нитки в межах одного процесу поділяють пам'ять, але кожен потік має власний стек і регістри, а потоки зберігають дані, що стосуються ниток, у купі. Нитки ніколи не виконуються самостійно, тому міжпотокове спілкування набагато швидше порівняно з міжпроцесорним зв’язком.

Процеси ніколи не поділяють одну пам'ять. Коли дочірній процес створює, він дублює місце пам'яті батьківського процесу. Комунікація процесів здійснюється за допомогою передачі даних, спільної пам'яті та розбору повідомлень. Переключення контексту між потоками відбувається дуже повільно.

Найкраща відповідь, яку я знайшов до цього часу, - це інтерфейс програмування Майкла Керріска :

У сучасних реалізаціях UNIX кожен процес може мати декілька потоків виконання. Один із способів передбачити потоки - це сукупність процесів, які мають спільну віртуальну пам'ять, а також цілий ряд інших атрибутів. Кожен потік виконує той самий програмний код і ділиться однаковою областю даних та купи. Однак у кожного потоку є свій стек, що містить локальні змінні та інформацію про зв'язок виклику функцій. [LPI 2.12]

Ця книга є джерелом великої ясності; У цій статті Джулія Еванс згадала про свою допомогу в з'ясуванні того, як насправді працюють групи Linux .

Приклад 1: JVM працює в одному процесі, а потоки в JVM ділять купу, що належить до цього процесу. Ось чому декілька потоків можуть отримати доступ до одного об’єкта. Нитки розділяють купу і мають власний простір для стеків. Ось як виклик методу однієї нитки методу та його локальних змінних захищає потоки в безпеці від інших потоків. Але купа не є безпечною для ниток і повинна бути синхронізована для безпеки потоку.

Вони майже однакові ... Але ключова відмінність полягає в тому, що нитка є легкою і процес має велику вагу з точки зору переключення контексту, робочого навантаження тощо.