ความแตกต่างระหว่างกระบวนการและเธรดคืออะไร?

ความแตกต่างทางเทคนิคระหว่างกระบวนการและเธรดคืออะไร

ฉันรู้สึกว่าคำว่า 'กระบวนการ' ถูกใช้มากเกินไปและยังมีฮาร์ดแวร์และซอฟต์แวร์เธรด กระบวนการเกี่ยวกับน้ำหนักเบาในภาษาอย่างErlang เป็นอย่างไร? มีเหตุผลที่ชัดเจนที่จะใช้คำหนึ่งในอีกคำหนึ่งหรือไม่?

ทั้งกระบวนการและเธรดเป็นลำดับของการดำเนินการที่เป็นอิสระ ความแตกต่างทั่วไปคือเธรด (ของกระบวนการเดียวกัน) ทำงานในพื้นที่หน่วยความจำที่ใช้ร่วมกันในขณะที่กระบวนการทำงานในพื้นที่หน่วยความจำแยกต่างหาก

ฉันไม่แน่ใจว่าหัวข้อ "ฮาร์ดแวร์" กับ "ซอฟต์แวร์" ที่คุณอาจอ้างถึงคืออะไร เธรดเป็นคุณลักษณะสภาพแวดล้อมการทำงานไม่ใช่คุณลักษณะของ CPU (แม้ว่าโดยทั่วไปแล้ว CPU จะมีการดำเนินการที่ทำให้เธรดมีประสิทธิภาพ)

Erlang ใช้คำว่า "กระบวนการ" เนื่องจากไม่ได้เปิดเผยโมเดลการประมวลผลหน่วยความจำแบบหลายหน่วยความจำที่ใช้ร่วมกัน การเรียกพวกเขาว่า "เธรด" หมายความว่าพวกเขามีหน่วยความจำที่ใช้ร่วมกัน

กระบวนการ
แต่ละกระบวนการจัดเตรียมทรัพยากรที่จำเป็นสำหรับการดำเนินการโปรแกรม กระบวนการมีพื้นที่ที่อยู่เสมือนรหัสเรียกทำงานเปิดจัดการกับวัตถุระบบบริบทความปลอดภัยตัวระบุกระบวนการที่ไม่ซ้ำกันตัวแปรสภาพแวดล้อมคลาสลำดับความสำคัญขนาดการทำงานขั้นต่ำและสูงสุดและขนาดของการดำเนินการอย่างน้อยหนึ่งเธรด แต่ละกระบวนการเริ่มต้นด้วยเธรดเดี่ยวซึ่งมักเรียกว่าเธรดหลัก แต่สามารถสร้างเธรดเพิ่มเติมจากเธรดใด ๆ

เกลียว
เธรดเป็นเอนทิตีภายในกระบวนการที่สามารถกำหนดเวลาสำหรับการดำเนินการ เธรดทั้งหมดของกระบวนการแบ่งปันพื้นที่ที่อยู่เสมือนและทรัพยากรระบบ นอกจากนี้แต่ละเธรดยังคงมีตัวจัดการข้อยกเว้นลำดับความสำคัญของการกำหนดเวลาหน่วยเก็บข้อมูลโลคัลเธรดตัวระบุเธรดเฉพาะและชุดโครงสร้างที่ระบบจะใช้เพื่อบันทึกบริบทเธรดจนกว่าจะถูกกำหนดเวลา บริบทเธรดประกอบด้วยชุดของการลงทะเบียนของเครื่อง, สแตกเคอร์เนล, บล็อกสภาพแวดล้อมของเธรด, และสแต็กผู้ใช้ในพื้นที่ที่อยู่ของกระบวนการของเธรด เธรดสามารถมีบริบทการรักษาความปลอดภัยของตนเองซึ่งสามารถใช้สำหรับการแอบอ้างลูกค้า

ข้อมูลนี้พบได้ใน Microsoft Docs ที่นี่: เกี่ยวกับกระบวนการและเธรด

Microsoft Windows รองรับมัลติทาสกิ้งแบบ preemptive ซึ่งสร้างผลกระทบของการดำเนินการหลายเธรดพร้อมกันจากหลายกระบวนการ บนคอมพิวเตอร์ที่มีตัวประมวลผลหลายระบบสามารถดำเนินการเธรดได้มากเนื่องจากมีตัวประมวลผลบนคอมพิวเตอร์พร้อมกัน

กระบวนการ:

• อินสแตนซ์ที่กำลังดำเนินการของโปรแกรมเรียกว่ากระบวนการ
• ระบบปฏิบัติการบางระบบใช้คำว่า 'task' เพื่ออ้างถึงโปรแกรมที่กำลังดำเนินการ
• กระบวนการจะถูกเก็บไว้ในหน่วยความจำหลักเสมอซึ่งเรียกว่าเป็นหน่วยความจำหลักหรือหน่วยความจำเข้าถึงโดยสุ่ม
• ดังนั้นกระบวนการจึงถูกเรียกว่าเป็นเอนทิตีที่ใช้งานอยู่ มันจะหายไปหากรีบูตเครื่อง
• กระบวนการหลายอย่างอาจเชื่อมโยงกับโปรแกรมเดียวกัน
• บนระบบมัลติโปรเซสเซอร์กระบวนการหลายกระบวนการสามารถดำเนินการแบบขนาน
• บนระบบ uni-processor แม้ว่าจะไม่ได้รับการขนานอย่างแท้จริง แต่จะใช้อัลกอริทึมการจัดกำหนดการกระบวนการและตัวประมวลผลถูกกำหนดให้ดำเนินการแต่ละกระบวนการในแต่ละครั้งที่ให้ภาพลวงตาของการเกิดพร้อมกัน
• ตัวอย่าง:การดำเนินการหลายอินสแตนซ์ของโปรแกรม 'เครื่องคิดเลข' แต่ละอินสแตนซ์ถูกเรียกว่าเป็นกระบวนการ

เกลียว:

• เธรดเป็นส่วนย่อยของกระบวนการ
• มันเรียกว่าเป็น 'กระบวนการที่มีน้ำหนักเบา' เนื่องจากคล้ายกับกระบวนการจริง แต่ดำเนินการภายในบริบทของกระบวนการและแบ่งปันทรัพยากรเดียวกันที่จัดสรรให้กับกระบวนการโดยเคอร์เนล
• โดยปกติแล้วกระบวนการจะมีการควบคุมเพียงหนึ่งเธรดเท่านั้น - ชุดคำสั่งเครื่องหนึ่งชุดที่ทำงานพร้อมกัน
• กระบวนการอาจประกอบด้วยหลายเธรดของการดำเนินการที่ดำเนินการคำสั่งพร้อมกัน
• การควบคุมหลายเธรดสามารถใช้ประโยชน์จากความขนานที่แท้จริงที่เป็นไปได้ในระบบมัลติโปรเซสเซอร์
• บนระบบ uni-processor มีการใช้อัลกอริทึมการจัดตารางเวลาเธรดและตัวประมวลผลถูกกำหนดให้รันแต่ละเธรดทีละตัว
• เธรดทั้งหมดที่ทำงานภายในกระบวนการใช้พื้นที่ที่อยู่ร่วมกันตัวอธิบายไฟล์สแต็กและแอตทริบิวต์อื่น ๆ ที่เกี่ยวข้องกับกระบวนการเดียวกัน
• เนื่องจากเธรดของกระบวนการแชร์หน่วยความจำเดียวกันการซิงโครไนซ์การเข้าถึงข้อมูลที่ใช้ร่วมกันภายในกระบวนการทำให้ได้รับความสำคัญอย่างที่ไม่เคยมีมาก่อน

ฉันยืมข้อมูลข้างต้นจากKnowledge Quest! บล็อก

อันดับแรกให้ดูที่ด้านทฤษฎี คุณต้องเข้าใจว่ากระบวนการใดที่เป็นแนวคิดในการเข้าใจความแตกต่างระหว่างกระบวนการและเธรดและสิ่งที่ใช้ร่วมกันระหว่างพวกเขา

เรามีดังต่อไปนี้จากส่วน2.2.2 โมเดลเธรดคลาสสิคในระบบปฏิบัติการสมัยใหม่ 3eโดย Tanenbaum:

แบบจำลองกระบวนการขึ้นอยู่กับแนวคิดอิสระสองประการ: การจัดกลุ่มทรัพยากรและการดำเนินการ บางครั้งมันก็มีประโยชน์ที่จะแยกพวกเขา นี่คือที่มาในหัวข้อ ....

เขาพูดต่อ:

วิธีหนึ่งในการดูกระบวนการคือมันเป็นวิธีการจัดกลุ่มทรัพยากรที่เกี่ยวข้องเข้าด้วยกัน กระบวนการมีพื้นที่ที่อยู่ซึ่งประกอบด้วยข้อความโปรแกรมและข้อมูลรวมถึงทรัพยากรอื่น ๆ ทรัพยากรเหล่านี้อาจรวมถึงไฟล์ที่เปิดกระบวนการลูกสัญญาณเตือนที่ค้างอยู่ตัวจัดการสัญญาณข้อมูลบัญชีและอื่น ๆ โดยการรวมเข้าด้วยกันในรูปแบบของกระบวนการพวกเขาสามารถจัดการได้ง่ายขึ้น อีกแนวคิดหนึ่งที่กระบวนการมีคือการประมวลผลเธรดโดยปกติจะย่อให้เหลือเพียงเธรด เธรดมีตัวนับโปรแกรมที่ติดตามคำสั่งที่จะดำเนินการถัดไป มีการลงทะเบียนซึ่งเก็บตัวแปรการทำงานปัจจุบัน มันมีสแต็กซึ่งมีประวัติการดำเนินการโดยมีหนึ่งเฟรมสำหรับแต่ละโพรซีเดอร์ที่เรียกว่า แต่ยังไม่ได้ส่งคืนจาก แม้ว่าเธรดจะต้องดำเนินการในบางกระบวนการ เธรดและกระบวนการเป็นแนวคิดที่แตกต่างและสามารถแยกได้ กระบวนการใช้เพื่อจัดกลุ่มทรัพยากรเข้าด้วยกัน เธรดเป็นเอนทิตีที่กำหนดเวลาไว้สำหรับการดำเนินการกับ CPU

ยิ่งกว่านั้นเขามีตารางต่อไปนี้:

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        |

มาจัดการกับปัญหาการมัลติเธรดของฮาร์ดแวร์ คลาสสิกซีพียูจะรองรับการประมวลผลเธรดเดียวรักษาสถานะของเธรดผ่านตัวนับโปรแกรมเดี่ยวและชุดการลงทะเบียน แต่จะเกิดอะไรขึ้นหากมีแคชพลาด ใช้เวลานานในการดึงข้อมูลจากหน่วยความจำหลักและในขณะที่สิ่งที่เกิดขึ้นซีพียูกำลังนั่งอยู่เฉยๆ ดังนั้นบางคนมีความคิดที่จะมีสถานะของเธรดสองชุด (การลงทะเบียน PC +) เพื่อให้เธรดอื่น (อาจอยู่ในกระบวนการเดียวกันหรืออาจอยู่ในกระบวนการอื่น) สามารถทำงานได้ในขณะที่เธรดอื่นกำลังรออยู่ในหน่วยความจำหลัก มีหลายชื่อและการใช้งานของแนวคิดนี้เช่น HyperThreading และ Sim พร้อมกันหลายเธรด (SMT สั้น ๆ )

ทีนี้มาดูด้านซอฟต์แวร์กันดีกว่า โดยทั่วไปมีสามวิธีที่สามารถใช้เธรดในฝั่งซอฟต์แวร์ได้

1. เธรดผู้ใช้
2. เธรดเคอร์เนล
3. การรวมกันของทั้งสอง

สิ่งที่คุณต้องใช้กับเธรดคือความสามารถในการบันทึกสถานะของ CPU และรักษาสแต็คจำนวนมากซึ่งสามารถทำได้หลายครั้งในพื้นที่ผู้ใช้ ข้อดีของเธรดพื้นที่ผู้ใช้คือการสลับเธรดเร็วสุดเนื่องจากคุณไม่จำเป็นต้องดักจับเคอร์เนลและความสามารถในการกำหนดเธรดของคุณตามที่คุณต้องการ ข้อเสียเปรียบที่ใหญ่ที่สุดคือการไม่สามารถปิดกั้น I / O (ซึ่งจะปิดกั้นกระบวนการทั้งหมดและเป็นเธรดผู้ใช้ทั้งหมด) ซึ่งเป็นหนึ่งในสาเหตุใหญ่ที่เราใช้เธรดในตอนแรก การบล็อก I / O โดยใช้เธรดทำให้การออกแบบโปรแกรมง่ายขึ้นอย่างมากในหลาย ๆ กรณี

เธรดเคอร์เนลมีข้อดีของความสามารถในการใช้การบล็อก I / O นอกเหนือจากการปล่อยปัญหาการจัดกำหนดการทั้งหมดไปยังระบบปฏิบัติการ แต่สวิตช์แต่ละเธรดจำเป็นต้องวางกับดักในเคอร์เนลซึ่งอาจค่อนข้างช้า อย่างไรก็ตามหากคุณสลับเธรดเนื่องจาก I / O ที่ถูกบล็อกนี่ไม่ใช่ปัญหาจริง ๆ เนื่องจากการดำเนินการ I / O อาจติดอยู่ในเคอร์เนลแล้ว

อีกวิธีคือการรวมสองรายการเข้าด้วยกันพร้อมกับเคอร์เนลหลายเธรดแต่ละรายการมีหลายเธรดผู้ใช้

ดังนั้นเมื่อกลับมาที่คำถามเกี่ยวกับคำศัพท์คุณจะเห็นว่ากระบวนการและการดำเนินการเป็นสองแนวคิดที่แตกต่างกันและการเลือกคำที่คุณต้องการใช้นั้นขึ้นอยู่กับสิ่งที่คุณกำลังพูดถึง เกี่ยวกับคำว่า "กระบวนการน้ำหนักเบา" ฉันไม่เห็นจุดนั้นเพราะไม่ได้ถ่ายทอดสิ่งที่เกิดขึ้นเช่นเดียวกับคำว่า

เพื่ออธิบายเพิ่มเติมเกี่ยวกับการเขียนโปรแกรมพร้อมกัน

1. กระบวนการมีสภาพแวดล้อมการดำเนินการที่มีอยู่ในตัวเอง โดยทั่วไปกระบวนการมีชุดทรัพยากรการใช้งานพื้นฐานที่สมบูรณ์และเป็นส่วนตัว โดยเฉพาะอย่างยิ่งแต่ละกระบวนการมีพื้นที่หน่วยความจำของตัวเอง

2. เธรดมีอยู่ภายในกระบวนการ - ทุกกระบวนการมีอย่างน้อยหนึ่งรายการ เธรดแชร์ทรัพยากรของกระบวนการรวมถึงหน่วยความจำและไฟล์ที่เปิดอยู่ สิ่งนี้ทำให้การสื่อสารมีประสิทธิภาพ แต่อาจเป็นปัญหาได้

คำนึงถึงคนทั่วไปโดยเฉพาะ

บนคอมพิวเตอร์ของคุณเปิด Microsoft Word และเว็บเบราว์เซอร์ เราเรียกกระบวนการทั้งสองนี้

ใน Microsoft word คุณพิมพ์บางอย่างและมันจะได้รับการบันทึกโดยอัตโนมัติ ตอนนี้คุณจะสังเกตเห็นการแก้ไขและการบันทึกที่เกิดขึ้นในแบบคู่ขนาน - การแก้ไขในเธรดหนึ่งและการบันทึกในเธรดอื่น

แอปพลิเคชันประกอบด้วยหนึ่งกระบวนการขึ้นไป กระบวนการในแง่ที่ง่ายที่สุดคือโปรแกรมที่ดำเนินการ เธรดหนึ่งเธรดขึ้นไปรันในบริบทของกระบวนการ เธรดเป็นหน่วยพื้นฐานที่ระบบปฏิบัติการจัดสรรเวลาตัวประมวลผล เธรดสามารถดำเนินการส่วนหนึ่งส่วนใดของรหัสกระบวนการรวมถึงส่วนที่กำลังดำเนินการโดยเธรดอื่น ไฟเบอร์เป็นหน่วยของการดำเนินการที่ต้องกำหนดเวลาด้วยตนเองโดยแอปพลิเคชัน Fibres ทำงานในบริบทของเธรดที่กำหนดเวลาไว้

ขโมยมาจากที่นี่

กระบวนการคือชุดของรหัสหน่วยความจำข้อมูลและทรัพยากรอื่น ๆ เธรดคือลำดับของรหัสที่ถูกดำเนินการภายในขอบเขตของกระบวนการ คุณสามารถ (มักจะ) มีหลายหัวข้อที่ดำเนินการพร้อมกันภายในกระบวนการเดียวกัน

ตัวอย่างโลกแห่งความจริงสำหรับกระบวนการและเธรด สิ่งนี้จะให้แนวคิดพื้นฐานเกี่ยวกับเธรดและกระบวนการ

ฉันยืมข้อมูลข้างต้นจากคำตอบของ Scott Langham - ขอบคุณ

กระบวนการ:

1. กระบวนการเป็นกระบวนการที่มีน้ำหนักมาก
2. กระบวนการเป็นโปรแกรมแยกต่างหากที่มีหน่วยความจำข้อมูลทรัพยากร ฯลฯ
3. กระบวนการถูกสร้างขึ้นโดยใช้วิธี fork ()
4. การสลับบริบทระหว่างกระบวนการใช้เวลานาน
   

ตัวอย่าง:
พูดเปิดเบราว์เซอร์ใด ๆ (mozilla, Chrome, IE) ณ จุดนี้กระบวนการใหม่จะเริ่มดำเนินการ

หัวข้อ:

1. เธรดเป็นกระบวนการที่มีน้ำหนักเบาเธรดถูกรวมภายในกระบวนการ
2. เธรดมีหน่วยความจำข้อมูลทรัพยากรไฟล์ ฯลฯ
3. หัวข้อถูกสร้างขึ้นโดยใช้วิธีการโคลน ()
4. การสลับบริบทระหว่างเธรดไม่ต้องใช้เวลามากในการดำเนินการ
   

ตัวอย่าง: การ
เปิดหลายแท็บในเบราว์เซอร์

• ทุกกระบวนการเป็นเธรด (เธรดหลัก)
• แต่ทุกเธรดไม่ใช่กระบวนการ มันเป็นส่วนหนึ่ง (เอนทิตี) ของกระบวนการ

ทั้งเธรดและกระบวนการเป็นหน่วยอะตอมมิกของการจัดสรรทรัพยากรระบบปฏิบัติการ (เช่นมีรูปแบบการทำงานพร้อมกันที่อธิบายถึงวิธีการแบ่งเวลา CPU ระหว่างพวกเขาและรูปแบบของการเป็นเจ้าของทรัพยากรระบบปฏิบัติการอื่น ๆ ) มีความแตกต่างใน:

• ทรัพยากรที่ใช้ร่วมกัน (เธรดคือการแชร์หน่วยความจำตามคำจำกัดความพวกเขาไม่ได้เป็นเจ้าของอะไรยกเว้นสแต็กและตัวแปรโลคัลกระบวนการยังสามารถแชร์หน่วยความจำได้ แต่มีกลไกแยกต่างหากสำหรับการบำรุงรักษาโดย OS)
• พื้นที่จัดสรร (พื้นที่เคอร์เนลสำหรับกระบวนการเทียบกับพื้นที่ผู้ใช้สำหรับเธรด)

Greg Hewgill ด้านบนนั้นถูกต้องเกี่ยวกับความหมายของ Erlang ของคำว่า "กระบวนการ" และที่นี่มีการอภิปรายว่าทำไม Erlang สามารถทำกระบวนการที่มีน้ำหนักเบาได้

ทั้งกระบวนการและเธรดเป็นลำดับของการดำเนินการที่เป็นอิสระ ความแตกต่างทั่วไปคือเธรด (ของกระบวนการเดียวกัน) ทำงานในพื้นที่หน่วยความจำที่ใช้ร่วมกันในขณะที่กระบวนการทำงานในพื้นที่หน่วยความจำแยกต่างหาก

กระบวนการ

เป็นโปรแกรมที่ทำงาน มันมีส่วนของข้อความเช่นรหัสโปรแกรมกิจกรรมปัจจุบันที่แสดงโดยค่าของตัวนับโปรแกรม & เนื้อหาของตัวประมวลผลที่ลงทะเบียน นอกจากนี้ยังมีกระบวนการสแต็กที่มีข้อมูลชั่วคราว (เช่นพารามิเตอร์ฟังก์ชัน, ตัวแปรที่ส่งคืนและตัวแปรภายในเครื่อง) และส่วนข้อมูลซึ่งมีตัวแปรทั่วโลก กระบวนการอาจรวมถึงฮีปซึ่งเป็นหน่วยความจำที่จัดสรรแบบไดนามิกในระหว่างกระบวนการทำงาน

เกลียว

เธรดเป็นหน่วยพื้นฐานของการใช้งาน CPU ประกอบด้วย ID เธรดตัวนับโปรแกรมชุดการลงทะเบียนและสแต็ก มันแชร์กับเธรดอื่นที่เป็นของกระบวนการเดียวกันส่วนรหัสของมันส่วนข้อมูลและทรัพยากรระบบปฏิบัติการอื่น ๆ เช่นไฟล์และสัญญาณเปิด

- นำมาจากระบบปฏิบัติการโดย Galvin

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

Linus Torvalds (torvalds@cs.helsinki.fi)

อังคาร, 6 ส.ค. 1996 12:47:31 +0300 (EET DST)

ข้อความเรียงตาม: [วันที่] [กระทู้] [หัวเรื่อง] [ผู้เขียน]

ข้อความถัดไป: Bernd P. Ziller: "Re: โอ๊ะโอใน get_hash_table"

ข้อความก่อนหน้า: Linus Torvalds: "การสั่งซื้อคำขอ I / O ใหม่"

ในวันจันทร์ที่ 5 ส.ค. 1996 ปีเตอร์พี. ไอเซอร์โลห์เขียนว่า:

เราจำเป็นต้องรักษาแนวคิดของเธรดให้ชัดเจน มีคนจำนวนมากเกินไปที่จะสร้างความสับสนให้กับกระบวนการ การสนทนาต่อไปนี้ไม่ได้สะท้อนถึงสถานะปัจจุบันของ linux แต่เป็นการพยายามอยู่ในระดับสูง

NO!

ไม่มีเหตุผลที่จะคิดว่า "เธรด" และ "กระบวนการ" เป็นเอนทิตีที่แยกจากกัน นั่นเป็นวิธีที่ทำกันตามธรรมเนียม แต่โดยส่วนตัวฉันคิดว่ามันเป็นความผิดพลาดครั้งใหญ่ที่จะคิดแบบนั้น เหตุผลเดียวที่คิดว่าวิธีนี้คือสัมภาระทางประวัติศาสตร์

ทั้งเธรดและกระบวนการต่างก็มีอยู่เพียงสิ่งเดียว: "บริบทของการดำเนินการ" การพยายามแยกแยะกรณีที่แตกต่างกันเป็นเพียงการ จำกัด ตัวเอง

"บริบทของการดำเนินการ" ซึ่งต่อไปนี้เรียกว่า COE เป็นเพียงการรวมกลุ่มของทุกสถานะของ COE นั้น สถานะนั้นรวมถึงสิ่งต่าง ๆ เช่นสถานะ CPU (ลงทะเบียน ฯลฯ ), สถานะ MMU (การแมปหน้า), สถานะการอนุญาต (uid, gid) และ "สถานะการสื่อสาร" ต่างๆ (เปิดไฟล์ตัวจัดการสัญญาณ ฯลฯ ) ตามเนื้อผ้าความแตกต่างระหว่าง "เธรด" และ "กระบวนการ" นั้นโดยทั่วไปแล้วว่าเธรดมีสถานะ CPU (+ อาจเป็นสถานะขั้นต่ำอื่น ๆ ) ในขณะที่บริบทอื่นทั้งหมดมาจากกระบวนการ แต่นั่นเป็นเพียง หนึ่งในวิธีการแบ่งรัฐรวมของ COE และมีอะไรที่บอกว่ามันเป็นวิธีการที่เหมาะสมที่จะทำมัน การ จำกัด ตัวเองให้อยู่ในประเภทของภาพนั้นเป็นเพียงความโง่เขลา

วิธีที่ Linux คิดเกี่ยวกับสิ่งนี้ (และวิธีที่ฉันต้องการให้สิ่งต่าง ๆ ทำงานได้) ก็คือไม่มีสิ่งเช่น "กระบวนการ" หรือ "เธรด" มีเพียงจำนวนทั้งสิ้นของ COE (เรียกว่า "งาน" โดย Linux) COE ที่แตกต่างกันสามารถแบ่งปันบางส่วนของบริบทของพวกเขาด้วยกันและเซตย่อยหนึ่งของการแบ่งปันนั้นคือการตั้งค่า "เธรด" / "กระบวนการ" แบบดั้งเดิม แต่ควรจะเห็นว่าเป็นเซตย่อยเท่านั้น (มันเป็นชุดย่อยที่สำคัญ ไม่ได้มาจากการออกแบบ แต่มาจากมาตรฐาน: เราต้องการเรียกใช้โปรแกรมเธรดที่สอดคล้องกับมาตรฐานด้านบนของ Linux ด้วย)

ในระยะสั้น: อย่าออกแบบวิธีคิดของเธรด / กระบวนการ เคอร์เนลควรได้รับการออกแบบตามวิธีคิดของ COE และจากนั้นไลบรารี pthreads สามารถเอ็กซ์พอร์ตอินเตอร์เฟส pthreads ที่ จำกัด ไปยังผู้ใช้ที่ต้องการใช้วิธีการดู COE นั้น

เป็นตัวอย่างของสิ่งที่เป็นไปได้เมื่อคุณคิดว่า COE ตรงข้ามกับเธรด / กระบวนการ:

• คุณสามารถทำโปรแกรม "cd" ภายนอกซึ่งเป็นสิ่งที่เป็นไปไม่ได้ใน UNIX และ / หรือกระบวนการ / เธรด (ตัวอย่างที่งี่เง่า แต่ความคิดคือคุณสามารถมี "โมดูล" เหล่านี้ซึ่งไม่ จำกัด UNIX แบบดั้งเดิม การตั้งค่า / เธรด) ทำ:

โคลน (CLONE_VM | CLONE_FS);

ลูก: execve ("external-cd");

/ * "execve ()" จะยกเลิกการเชื่อมโยง VM ดังนั้นเหตุผลเดียวที่เราใช้ CLONE_VM ก็เพื่อทำให้การโคลนนิ่งเร็วขึ้น * /

• คุณสามารถทำ "vfork ()" ตามธรรมชาติ (มันต้องการการสนับสนุนเคอร์เนลน้อยที่สุด แต่การสนับสนุนที่เหมาะกับวิธีคิด CUA อย่างสมบูรณ์แบบ):

โคลน (CLONE_VM);

เด็ก: ยังคงทำงานต่อไปในที่สุดเอ็กซีคิวต์ ()

แม่: รอการประหารชีวิต

• คุณสามารถทำ "IO deamons" ภายนอก:

โคลน (CLONE_FILES);

child: ตัวอธิบายไฟล์เปิดเป็นต้น

แม่: ใช้ fd ของเด็กเปิดและ vv

งานทั้งหมดข้างต้นเพราะคุณไม่ได้ผูกติดอยู่กับวิธีคิด / กระบวนการ ลองนึกถึงเว็บเซิร์ฟเวอร์ที่ซึ่งสคริปต์ CGI นั้นถูกทำเป็น "เธรดการทำงาน" คุณไม่สามารถทำเช่นนี้กับเธรดดั้งเดิมเนื่องจากเธรดดั้งเดิมต้องแชร์พื้นที่ที่อยู่ทั้งหมดเสมอดังนั้นคุณต้องลิงก์ในทุกสิ่งที่คุณต้องการทำในเว็บเซิร์ฟเวอร์เอง ("เธรด" ไม่สามารถทำงานได้ ปฏิบัติการอื่น)

ความคิดนี้เป็น "บริบทของการดำเนินการปัญหา" แทนงานของคุณในขณะนี้สามารถเลือกที่จะรันโปรแกรมภายนอก (= แยกพื้นที่ที่อยู่จากแม่) ฯลฯ ถ้าพวกเขาต้องการหรือพวกเขาสามารถทำได้สำหรับทุกอย่างหุ้นเช่นกับผู้ปกครองยกเว้นสำหรับ file descriptors (เพื่อให้ sub- "threads" สามารถเปิดไฟล์จำนวนมากโดยที่ parent ไม่ต้องกังวลพวกมันจะปิดโดยอัตโนมัติเมื่อ sub-"thread" ออกจากและมันไม่ได้ใช้ fd's ใน parent) .

ลองนึกถึงเธรด "inetd" คุณต้องการค่าใช้จ่ายต่ำ fork + exec ดังนั้นด้วยวิธี Linux คุณสามารถแทนที่จะใช้ "fork ()" คุณเขียน inetd แบบมัลติเธรดที่แต่ละเธรดถูกสร้างด้วย CLONE_VM (พื้นที่ที่อยู่ที่ใช้ร่วมกัน แต่ไม่แชร์ไฟล์ ตัวอธิบาย ฯลฯ ) จากนั้นเด็กสามารถประหารชีวิตถ้ามันเป็นบริการภายนอก (ตัวอย่างเช่น rlogind) หรือบางทีมันอาจเป็นหนึ่งในบริการ inetd ภายใน (echo, timeofday) ซึ่งในกรณีที่มันเป็นเพียงสิ่งที่มันและออกจาก

คุณไม่สามารถทำได้ด้วย "thread" / "process"

ไลนัส

พยายามตอบจากมุมมอง OS ของเคอร์เนล Linux

โปรแกรมกลายเป็นกระบวนการเมื่อเรียกใช้งานในหน่วยความจำ กระบวนการมีพื้นที่อยู่ของตัวเองหมายถึงการมีส่วนต่างๆในหน่วยความจำเช่น.textsegement สำหรับการจัดเก็บรหัสเรียบเรียง.bssสำหรับการจัดเก็บแบบคงที่เตรียมหรือตัวแปรทั่วโลก ฯลฯ
แต่ละขั้นตอนจะมีของตัวเองโปรแกรมเคาน์เตอร์และผู้ใช้พื้นที่ของสแต็ค

ภายในเคอร์เนลแต่ละโพรเซสจะมีเคอร์เนลสแต็คของตัวเอง (ซึ่งถูกแยกออกจากสเปซของผู้ใช้พื้นที่สำหรับปัญหาด้านความปลอดภัย) และโครงสร้างที่มีชื่อtask_structซึ่งโดยทั่วไปจะแยกเป็นบล็อกควบคุมกระบวนการเก็บข้อมูลทั้งหมดที่เกี่ยวข้องกับกระบวนการ (และอีกอันมากมาย)
กระบวนการสามารถมีการดำเนินการหลายเธรด

พวกเขาอาศัยอยู่ในกระบวนการและแชร์พื้นที่ที่อยู่ของกระบวนการหลักพร้อมกับทรัพยากรอื่น ๆ ที่สามารถส่งผ่านในระหว่างการสร้างเธรดเช่นทรัพยากรระบบไฟล์การแบ่งปันสัญญาณที่รอดำเนินการแบ่งปันข้อมูล (ตัวแปรและคำแนะนำ) ทำให้เธรดมีน้ำหนักเบาและ จึงช่วยให้การสลับบริบทเร็วขึ้น

ภายในเคอร์เนลแต่ละเธรดมีสแตกเคอร์เนลของตัวเองพร้อมกับtask_structโครงสร้างที่กำหนดเธรด ดังนั้นเคอร์เนลจึงดูเธรดของกระบวนการเดียวกันกับเอนทิตีที่แตกต่างกันและสามารถกำหนดได้เอง เธรดในกระบวนการเดียวกันแบ่งปัน id ทั่วไปที่เรียกว่า id กลุ่มเธรด ( tgid) และยังมี id เฉพาะที่เรียกว่าเป็น id กระบวนการ ( pid)

พยายามตอบคำถามเกี่ยวกับโลก Java

กระบวนการคือการดำเนินการของโปรแกรม แต่เธรดเป็นลำดับการดำเนินการเดียวภายในกระบวนการ กระบวนการสามารถมีหลายเธรด เธรดบางครั้งเรียกว่ากระบวนการที่มีน้ำหนักเบากระบวนการที่มีน้ำหนักเบา

ตัวอย่างเช่น:

ตัวอย่างที่ 1: JVM ทำงานในกระบวนการเดียวและเธรดใน JVM จะแบ่งปันฮีปที่เป็นของกระบวนการนั้น นั่นคือเหตุผลที่หลายเธรดสามารถเข้าถึงวัตถุเดียวกันได้ เธรดแชร์ฮีปและมีพื้นที่สแต็กของตนเอง นี่เป็นวิธีที่การเรียกใช้เธรดหนึ่งเมธอดและตัวแปรโลคัลถูกเก็บรักษาไว้อย่างปลอดภัยจากเธรดอื่น แต่ฮีปนั้นไม่ปลอดภัยสำหรับเธรดและต้องซิงโครไนซ์เพื่อความปลอดภัยของเธรด

ตัวอย่างที่ 2: โปรแกรมอาจไม่สามารถวาดภาพได้ด้วยการอ่านการกดแป้น โปรแกรมจะต้องให้ความสนใจอย่างเต็มที่กับคีย์บอร์ดและขาดความสามารถในการจัดการเหตุการณ์มากกว่าหนึ่งครั้งจะทำให้เกิดปัญหา ทางออกที่ดีสำหรับปัญหานี้คือการดำเนินการอย่างราบรื่นของสองส่วนหรือมากกว่าของโปรแกรมในเวลาเดียวกัน หัวข้อช่วยให้เราสามารถทำเช่นนี้ ที่นี่รูปวาดเป็นกระบวนการและการอ่านการกดแป้นเป็นกระบวนการย่อย (เธรด)

ความแตกต่างระหว่างเธรดและกระบวนการ

กระบวนการเป็นอินสแตนซ์ที่กำลังดำเนินการของแอปพลิเคชันและเธรดเป็นเส้นทางของการดำเนินการภายในกระบวนการ นอกจากนี้กระบวนการสามารถมีหลายเธรดได้โปรดทราบว่าเธรดสามารถทำทุกอย่างที่กระบวนการสามารถทำได้ แต่เนื่องจากกระบวนการสามารถประกอบด้วยหลายเธรดเธรดอาจถูกพิจารณาว่าเป็นกระบวนการ 'จริงจัง' ดังนั้นความแตกต่างที่สำคัญระหว่างเธรดและกระบวนการคืองานที่แต่ละอันใช้เพื่อทำให้สำเร็จ หัวข้อที่ใช้สำหรับงานเล็ก ๆ ในขณะที่กระบวนการที่ใช้สำหรับงาน 'หนา' เพิ่มเติม - โดยทั่วไปการดำเนินการของโปรแกรมประยุกต์

ความแตกต่างระหว่างเธรดและโปรเซสคือเธรดภายในโปรเซสเดียวกันใช้พื้นที่แอดเดรสเดียวกันในขณะที่โปรเซสต่าง ๆ ไม่ทำ สิ่งนี้อนุญาตให้เธรดอ่านและเขียนไปยังโครงสร้างข้อมูลและตัวแปรเดียวกันและอำนวยความสะดวกในการสื่อสารระหว่างเธรด การสื่อสารระหว่างกระบวนการ - หรือที่เรียกว่า IPC หรือการสื่อสารระหว่างกระบวนการนั้นค่อนข้างยากและใช้ทรัพยากรมาก

นี่คือบทสรุปของความแตกต่างระหว่างเธรดและกระบวนการ:

1. เธรดสามารถสร้างได้ง่ายกว่ากระบวนการเนื่องจากไม่ต้องการพื้นที่ที่อยู่แยกต่างหาก

2. การมัลติเธรดต้องมีการเขียนโปรแกรมอย่างระมัดระวังเนื่องจากเธรดใช้โครงสร้างข้อมูลร่วมกันซึ่งควรแก้ไขได้ครั้งละหนึ่งเธรดเท่านั้น กระบวนการไม่ได้แบ่งที่อยู่เดียวกัน

3. หัวข้อถือว่าเบาเพราะใช้ทรัพยากรน้อยกว่ากระบวนการ

4. กระบวนการเป็นอิสระจากกัน เธรดเนื่องจากพื้นที่ที่อยู่เดียวกันนั้นมีการพึ่งพาซึ่งกันและกันจึงต้องใช้ความระมัดระวัง
   นี่เป็นอีกวิธีหนึ่งในการระบุข้อ 2 ข้างต้น

5. กระบวนการสามารถประกอบด้วยหลายเธรด

ต่อไปนี้คือสิ่งที่ผมได้จากหนึ่งในบทความในโครงการรหัส ฉันเดาว่ามันอธิบายทุกอย่างที่จำเป็นอย่างชัดเจน

เธรดเป็นอีกกลไกหนึ่งสำหรับแยกเวิร์กโหลดลงในสตรีมการดำเนินการแยกต่างหาก เธรดมีน้ำหนักเบากว่ากระบวนการ ซึ่งหมายความว่ามันมีความยืดหยุ่นน้อยกว่ากระบวนการที่เป่าเต็ม แต่สามารถเริ่มต้นได้เร็วขึ้นเพราะมีน้อยกว่าสำหรับระบบปฏิบัติการที่จะตั้งค่า เมื่อโปรแกรมประกอบด้วยสองเธรดขึ้นไปเธรดทั้งหมดจะแบ่งพื้นที่หน่วยความจำเดี่ยว กระบวนการจะได้รับพื้นที่ที่อยู่แยกต่างหาก เธรดทั้งหมดแชร์กองเดียว แต่แต่ละเธรดจะได้รับสแต็กของตัวเอง

กระบวนการ:

กระบวนการนั้นเป็นโปรแกรมในการดำเนินการ มันเป็นนิติบุคคลที่ใช้งานอยู่ ระบบปฏิบัติการบางระบบใช้คำว่า 'task' เพื่ออ้างถึงโปรแกรมที่กำลังดำเนินการ กระบวนการจะถูกเก็บไว้ในหน่วยความจำหลักเสมอซึ่งเรียกว่าเป็นหน่วยความจำหลักหรือหน่วยความจำเข้าถึงโดยสุ่ม ดังนั้นกระบวนการจึงถูกเรียกว่าเป็นเอนทิตีที่ใช้งานอยู่ มันจะหายไปหากรีบูตเครื่อง กระบวนการหลายอย่างอาจเชื่อมโยงกับโปรแกรมเดียวกัน บนระบบมัลติโปรเซสเซอร์กระบวนการหลายกระบวนการสามารถดำเนินการแบบขนาน บนระบบ uni-processor แม้ว่าจะไม่สามารถทำการขนานอย่างแท้จริงได้ แต่จะใช้อัลกอริทึมการจัดกำหนดการกระบวนการและตัวประมวลผลถูกกำหนดให้ดำเนินการแต่ละกระบวนการในแต่ละครั้ง ตัวอย่าง: การดำเนินการหลายอินสแตนซ์ของโปรแกรม 'เครื่องคิดเลข' แต่ละอินสแตนซ์ถูกเรียกว่าเป็นกระบวนการ

เกลียว:

เธรดเป็นส่วนย่อยของกระบวนการ มันเรียกว่าเป็น 'กระบวนการที่มีน้ำหนักเบา' เนื่องจากคล้ายกับกระบวนการจริง แต่ดำเนินการภายในบริบทของกระบวนการและแบ่งปันทรัพยากรเดียวกันที่จัดสรรให้กับกระบวนการโดยเคอร์เนล โดยทั่วไปกระบวนการมีการควบคุมเพียงหนึ่งเธรด - คำสั่งเครื่องหนึ่งชุดที่ดำเนินการพร้อมกัน กระบวนการอาจประกอบด้วยหลายเธรดของการดำเนินการที่ดำเนินการคำสั่งพร้อมกัน การควบคุมหลายเธรดสามารถใช้ประโยชน์จากความขนานที่แท้จริงที่เป็นไปได้ในระบบมัลติโปรเซสเซอร์ บนระบบ uni-processor จะใช้อัลกอริธึมการจัดตารางเวลาเธรดและตัวประมวลผลถูกกำหนดให้รันแต่ละเธรดทีละตัว เธรดทั้งหมดที่ทำงานภายในกระบวนการใช้พื้นที่ที่อยู่ร่วมกันตัวอธิบายไฟล์สแต็กและแอตทริบิวต์อื่น ๆ ที่เกี่ยวข้องกับกระบวนการเดียวกัน เนื่องจากเธรดของกระบวนการแชร์หน่วยความจำเดียวกัน

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

จากมุมมองของผู้สัมภาษณ์มีเพียง 3 สิ่งสำคัญที่ฉันต้องการจะได้ยินนอกจากสิ่งที่ชัดเจนเช่นกระบวนการสามารถมีหลายกระทู้:

1. เธรดใช้พื้นที่หน่วยความจำร่วมกันซึ่งหมายความว่าเธรดสามารถเข้าถึงหน่วยความจำจากหน่วยความจำเธรดของผู้อื่นได้ กระบวนการตามปกติไม่สามารถ
2. ทรัพยากร ทรัพยากร (หน่วยความจำด้ามจับซ็อกเก็ต ฯลฯ ) ถูกปล่อยเมื่อกระบวนการยุติไม่ใช่การยกเลิกเธรด
3. ความปลอดภัย กระบวนการมีโทเค็นความปลอดภัยที่แน่นอน ในทางกลับกันเธรดสามารถเลียนแบบผู้ใช้ / โทเค็นที่แตกต่างกันได้

ถ้าคุณต้องการมากกว่านี้คำตอบของ Scott Langham ก็ครอบคลุมทุกอย่าง ทั้งหมดนี้มาจากมุมมองของระบบปฏิบัติการ ภาษาที่ต่างกันสามารถใช้แนวคิดที่แตกต่างกันเช่นงานเธรดที่มีแสงน้อยเป็นต้น แต่เป็นเพียงวิธีการใช้เธรด (ของเส้นใยบน Windows) ไม่มีเธรดฮาร์ดแวร์และซอฟต์แวร์ มีฮาร์ดแวร์และซอฟต์แวร์ที่เป็นข้อยกเว้นและการขัดจังหวะหรือใช้โหมดเคอร์เนลหัวข้อ

1. เธรดทำงานในพื้นที่หน่วยความจำที่ใช้ร่วมกัน แต่กระบวนการทำงานในพื้นที่หน่วยความจำแยกต่างหาก
2. เธรดเป็นกระบวนการที่มีน้ำหนักเบา แต่กระบวนการเป็นกระบวนการที่มีน้ำหนักมาก
3. เธรดเป็นประเภทย่อยของกระบวนการ

สำหรับผู้ที่มีความสะดวกสบายในการเรียนรู้มากขึ้นโดยการแสดงภาพนี่คือแผนภาพที่มีประโยชน์ที่ฉันสร้างขึ้นเพื่ออธิบายกระบวนการและหัวข้อ
ฉันใช้ข้อมูลจาก MSDN - เกี่ยวกับกระบวนการและเธรด

มาจากโลกฝังตัวฉันต้องการเพิ่มว่าแนวคิดของกระบวนการมีอยู่ในโปรเซสเซอร์ "ใหญ่" เท่านั้น ( เดสก์ท็อปซีพียู ARM Cortex A-9 ) ที่มี MMU (หน่วยจัดการหน่วยความจำ) และระบบปฏิบัติการที่รองรับการใช้ MMU ( เช่นLinux ) ด้วยตัวประมวลผลขนาดเล็ก / เก่าตัวควบคุมขนาดเล็กและระบบปฏิบัติการ RTOS ขนาดเล็ก (ระบบปฏิบัติการแบบเรียลไทม์ ) เช่น freeRTOS ไม่มีการสนับสนุน MMU ดังนั้นจึงไม่มีกระบวนการยกเว้นเธรดเท่านั้น

หัวข้อสามารถเข้าถึงหน่วยความจำซึ่งกันและกันและถูกกำหนดโดยระบบปฏิบัติการในลักษณะที่สลับกันดังนั้นจึงปรากฏว่าทำงานแบบขนาน (หรือมีหลายคอร์ที่ทำงานแบบขนานจริงๆ)

กระบวนการในมืออื่น ๆ ที่อาศัยอยู่ในกระบะทรายส่วนตัวของพวกเขาจากหน่วยความจำเสมือนที่ให้บริการและรักษาโดย MMU สิ่งนี้มีประโยชน์เพราะช่วย:

1. รักษากระบวนการบั๊กกี้ไม่ให้กระทบทั้งระบบ
2. รักษาความปลอดภัยด้วยการทำให้ข้อมูลกระบวนการอื่นมองไม่เห็นและไม่สามารถเข้าถึงได้ งานจริงในกระบวนการได้รับการดูแลโดยหนึ่งหรือมากกว่าหนึ่งกระทู้

1. โดยทั่วไปเธรดเป็นส่วนหนึ่งของกระบวนการที่ไม่มีเธรดกระบวนการจะไม่สามารถทำงานได้
2. เธรดมีน้ำหนักเบาในขณะที่กระบวนการมีน้ำหนักมาก
3. การสื่อสารระหว่างกระบวนการต้องใช้เวลาในขณะที่ด้ายต้องใช้เวลาน้อยลง
4. เธรดสามารถแบ่งใช้พื้นที่หน่วยความจำเดียวกันในขณะที่กระบวนการแยกกัน

กระบวนการ : โปรแกรมภายใต้การดำเนินการเรียกว่ากระบวนการ

เธรด : เธรดเป็นฟังก์ชันที่ดำเนินการกับส่วนอื่น ๆ ของโปรแกรมตามแนวคิดของ "หนึ่งกับอีก" ดังนั้นเธรดเป็นส่วนหนึ่งของกระบวนการ ..

ฉันได้อ่านคำตอบเกือบทั้งหมดที่นั่นแล้วอนิจจาในฐานะนักเรียนระดับปริญญาตรีที่เข้าเรียนหลักสูตร OS ในปัจจุบันฉันไม่เข้าใจแนวคิดทั้งสอง ฉันหมายถึงพวกส่วนใหญ่ที่อ่านจากหนังสือระบบปฏิบัติการบางเล่มความแตกต่างเช่นเธรดสามารถเข้าถึงตัวแปรทั่วโลกในหน่วยธุรกรรมได้เนื่องจากพวกเขาใช้พื้นที่ที่อยู่ของกระบวนการ แต่คำถามใหม่ที่เกิดขึ้นว่าทำไมมีกระบวนการเรารู้แล้วกระทู้เป็นกระบวนการ vis-à-vis น้ำหนักเบามากขึ้น ได้อย่างรวดเร็ว Let 's ตัวอย่างต่อไปนี้โดยการใช้ภาพที่ตัดตอนมาจากหนึ่งในคำตอบก่อน ,

เรามี 3 หัวข้อที่ทำงานในครั้งเดียวในเอกสารคำเช่นสำนักงานฟรี สิ่งแรกคือการตรวจการสะกดคำโดยการขีดเส้นใต้ถ้าคำนั้นสะกดผิด ครั้งที่สองใช้เวลาและพิมพ์ตัวอักษรจากแป้นพิมพ์ และสุดท้ายจะบันทึกเอกสารในทุกช่วงเวลาสั้น ๆ เพื่อไม่ให้เอกสารสูญหายหากเกิดข้อผิดพลาด ในกรณีนี้ 3 เธรดไม่สามารถเป็น 3 โพรเซสเนื่องจากโพรเซสแชร์หน่วยความจำร่วมซึ่งเป็นที่อยู่ของโพรเซสและทำให้ทุกคนสามารถเข้าถึงเอกสารที่กำลังแก้ไขได้ ดังนั้นถนนคือเอกสารคำพร้อมกับรถดันดินสองอันซึ่งเป็นเกลียวแม้ว่าหนึ่งในนั้นจะขาดในภาพ

ในขณะที่การสร้างอัลกอริทึมใน Python (ภาษาที่ตีความ) ที่รวมเธรดหลายเธรดฉันรู้สึกประหลาดใจที่เห็นว่าเวลาดำเนินการไม่ได้ดีไปกว่าเมื่อเปรียบเทียบกับอัลกอริธึมตามลำดับที่ฉันสร้างขึ้นก่อนหน้านี้ ในความพยายามที่จะเข้าใจเหตุผลสำหรับผลลัพธ์นี้ฉันได้อ่านและเชื่อว่าสิ่งที่ฉันเรียนรู้นำเสนอบริบทที่น่าสนใจซึ่งจะช่วยให้เข้าใจความแตกต่างระหว่างมัลติเธรดและมัลติโพรเซสได้ดีขึ้น

ระบบมัลติคอร์อาจใช้หลายเธรดการดำเนินการดังนั้น Python จึงควรรองรับมัลติเธรด แต่ Python ไม่ใช่ภาษาที่คอมไพล์และเป็นภาษาที่ตีความ¹แทน ซึ่งหมายความว่าโปรแกรมจะต้องตีความเพื่อให้ทำงานได้และล่ามจะไม่ทราบโปรแกรมก่อนที่จะเริ่มดำเนินการ สิ่งที่รู้ก็คือกฎของ Python จากนั้นจะใช้กฎเหล่านั้นแบบไดนามิก การปรับให้เหมาะสมใน Python ต้องเป็นการปรับให้เหมาะสมที่สุดของตัวแปลเองและไม่ใช่รหัสที่จะเรียกใช้ สิ่งนี้ตรงกันข้ามกับภาษาที่คอมไพล์เช่น C ++ และมีผลต่อการมัลติเธรดใน Python Python ใช้ Global Interpreter Lock เพื่อจัดการมัลติเธรด

ในทางกลับกันภาษาที่คอมไพล์แล้วก็แปลว่าดี โปรแกรมจะถูกประมวลผล "ทั้งหมด" ซึ่งเป็นครั้งแรกที่มันถูกตีความตามคำจำกัดความของไวยากรณ์แล้วแมปกับการเป็นตัวแทนของผู้ไม่เชื่อเรื่องพระเจ้ากลางภาษาและในที่สุดก็เชื่อมโยงลงในรหัสปฏิบัติการ กระบวนการนี้อนุญาตให้โค้ดถูกออปติไมซ์อย่างสูงเนื่องจากมันพร้อมใช้งานในเวลาที่ทำการรวบรวม การโต้ตอบและความสัมพันธ์ของโปรแกรมต่าง ๆ จะถูกกำหนดในเวลาที่สามารถเรียกใช้งานได้และการตัดสินใจที่ดีเกี่ยวกับการปรับให้เหมาะสม

ในสภาพแวดล้อมที่ทันสมัยล่าม Pythons จะต้องอนุญาตให้มีการทำเกลียวหลายเธรดและสิ่งนี้จะต้องปลอดภัยและมีประสิทธิภาพ นี่คือที่ซึ่งความแตกต่างระหว่างการเป็นภาษาที่ถูกตีความกับภาษาที่คอมไพล์เข้ามาในรูปภาพ ล่ามจะต้องไม่รบกวนข้อมูลที่แบ่งปันภายในจากเธรดที่แตกต่างกันในขณะที่ในขณะเดียวกันก็ปรับการใช้โปรเซสเซอร์ให้เหมาะสมเพื่อการคำนวณ

ดังที่บันทึกไว้ในโพสต์ก่อนหน้านี้ทั้งกระบวนการและเธรดเป็นการดำเนินการตามลำดับอิสระโดยมีความแตกต่างหลักคือหน่วยความจำที่ใช้ร่วมกันข้ามหลายเธรดของกระบวนการขณะที่กระบวนการแยกพื้นที่หน่วยความจำออก

ในข้อมูลไพ ธ อนได้รับการปกป้องจากการเข้าถึงพร้อมกันโดยเธรดที่แตกต่างกันโดย Global Interpreter Lock มันต้องการให้ในโปรแกรม Python ใด ๆ สามารถเรียกใช้งานหนึ่งเธรดได้ตลอดเวลา ในทางตรงกันข้ามมันเป็นไปได้ที่จะเรียกใช้หลายกระบวนการตั้งแต่หน่วยความจำสำหรับแต่ละกระบวนการแยกจากกระบวนการอื่น ๆ และกระบวนการสามารถทำงานบนหลายแกน

¹ Donald Knuth มีคำอธิบายที่ดีเกี่ยวกับรูทีนการตีความในศิลปะการเขียนโปรแกรมคอมพิวเตอร์: อัลกอริทึมพื้นฐาน

เธรดภายในกระบวนการเดียวกันใช้หน่วยความจำร่วมกัน แต่แต่ละเธรดมีสแต็กและรีจิสเตอร์ของตัวเองและเธรดจะเก็บข้อมูลเฉพาะเธรดในฮีป เธรดไม่ดำเนินการอย่างอิสระดังนั้นการสื่อสารระหว่างเธรดจึงเร็วกว่าเมื่อเปรียบเทียบกับการสื่อสารระหว่างกระบวนการ

กระบวนการไม่เคยแบ่งปันหน่วยความจำเดียวกัน เมื่อกระบวนการลูกสร้างกระบวนการทำซ้ำตำแหน่งหน่วยความจำของกระบวนการหลัก การสื่อสารกระบวนการทำโดยใช้ไพพ์หน่วยความจำที่แบ่งใช้และการแยกวิเคราะห์ข้อความ การสลับบริบทระหว่างเธรดช้ามาก

คำตอบที่ดีที่สุดที่ฉันพบคือMichael Kerrisk 'The Linux Programming Interface' :

ในการใช้งาน UNIX ที่ทันสมัยแต่ละกระบวนการสามารถมีหลายเธรดการดำเนินการ วิธีหนึ่งในการมองเห็นเธรดคือชุดของกระบวนการที่ใช้หน่วยความจำเสมือนเดียวกันรวมถึงช่วงของคุณลักษณะอื่น ๆ แต่ละเธรดกำลังเรียกใช้งานรหัสโปรแกรมเดียวกันและแชร์พื้นที่ข้อมูลและฮีปเดียวกัน อย่างไรก็ตามแต่ละเธรดมีสแต็กของตนเองซึ่งมีตัวแปรโลคัลและข้อมูลการเชื่อมโยงการเรียกใช้ฟังก์ชัน [LPI 2.12]

หนังสือเล่มนี้เป็นแหล่งของความชัดเจน จูเลียอีแวนส์กล่าวถึงความช่วยเหลือในการล้างขึ้นว่ากลุ่มลินุกซ์จริงๆทำงานในบทความนี้

ตัวอย่างที่ 1: JVM ทำงานในกระบวนการเดียวและเธรดใน JVM แบ่งปันฮีปที่เป็นของกระบวนการนั้น นั่นคือสาเหตุที่หลายเธรดสามารถเข้าถึงวัตถุเดียวกันได้ เธรดแชร์ฮีปและมีพื้นที่สแต็กของตนเอง นี่เป็นวิธีที่การเรียกใช้เธรดหนึ่งเมธอดและตัวแปรโลคัลถูกเก็บรักษาเธรดอย่างปลอดภัยจากเธรดอื่น แต่ฮีปนั้นไม่ปลอดภัยสำหรับเธรดและต้องซิงโครไนซ์เพื่อความปลอดภัยของเธรด

มันเกือบจะเหมือนกัน ... แต่ความแตกต่างที่สำคัญคือเธรดนั้นมีน้ำหนักเบาและกระบวนการนั้นมีน้ำหนักมากในแง่ของการสลับบริบทโหลดงานและอื่น ๆ