ทรัพยากรใดบ้างที่ใช้ร่วมกันระหว่างเธรด

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

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

Q. คุณรู้ส่วนที่โปรแกรมแบ่งหรือไม่?

คำตอบของฉัน: อ๋อ (คิดว่าเป็นเรื่องง่าย) Stack, Data, Code, Heap

ถามบอกฉันหน่อย: กลุ่มหัวข้อใดที่แชร์กันบ้าง

ฉันไม่สามารถตอบคำถามนี้และจบลงด้วยการบอกพวกเขาทั้งหมด

ได้โปรดใครบ้างสามารถแสดงคำตอบที่ถูกต้องและน่าประทับใจสำหรับความแตกต่างระหว่างกระบวนการและเธรดได้หรือไม่?

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

จากWikipedia (ฉันคิดว่าจะเป็นคำตอบที่ดีสำหรับผู้สัมภาษณ์: P)

เธรดแตกต่างจากกระบวนการระบบมัลติทาสกิ้งแบบดั้งเดิมที่:

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

สิ่งที่ต้องชี้ให้เห็นก็คือมีคำถามสองด้านจริงๆ - ด้านทฤษฎีและด้านการนำไปใช้

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

เรามีดังต่อไปนี้จากส่วน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        |

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

บอกผู้สัมภาษณ์ว่าขึ้นอยู่กับการนำระบบปฏิบัติการมาใช้ทั้งหมด

ยกตัวอย่างเช่น Windows x86 มีเพียง2ส่วน [1] รหัสและข้อมูล และพวกเขาทั้งคู่ถูกแมปไปยังพื้นที่ที่อยู่ 2GB (เชิงเส้นผู้ใช้) ทั้งหมด ฐาน = 0, จำกัด = 2GB พวกเขาจะทำอย่างใดอย่างหนึ่ง แต่ x86 ไม่อนุญาตให้ส่วนเป็นทั้งอ่าน / เขียนและดำเนิน ดังนั้นพวกเขาจึงสร้างสองและตั้ง CS ให้ชี้ไปที่ code descriptor และส่วนที่เหลือ (DS, ES, SS, ฯลฯ ) ให้ชี้ไปที่อีก [2] แต่ทั้งคู่ชี้ไปที่สิ่งเดียวกัน!

บุคคลที่สัมภาษณ์คุณทำข้อสันนิษฐานที่ซ่อนเร้นว่าเขา / เธอไม่ได้กล่าวและนั่นเป็นกลอุบายโง่ ๆ ที่จะดึง

ดังนั้นเกี่ยวกับ

Q. บอกส่วนแบ่งเธรดที่ใช้ร่วมกันบ้าง

เซ็กเมนต์ไม่เกี่ยวข้องกับคำถามอย่างน้อยใน Windows หัวข้อแบ่งปันพื้นที่ที่อยู่ทั้งหมด มีเซ็กเมนต์สแต็กเพียง 1 รายการคือ SS และชี้ไปยังสิ่งเดียวกันที่ DS, ES และ CS ทำ [2] คือพื้นที่ที่ผู้ใช้เลือดทั้งหมด 0-2GB แน่นอนว่านั่นไม่ได้หมายความว่ากระทู้มีเพียง 1 กอง โดยปกติแล้วแต่ละกลุ่มจะมีสแต็กของตัวเอง แต่เซ็กเมนต์ x86 ไม่ได้ถูกใช้เพื่อจุดประสงค์นี้

บางที * ระวังจะทำสิ่งที่แตกต่าง ใครจะรู้. สถานที่ตั้งคำถามนั้นมีพื้นฐานมาจากแตก

1. อย่างน้อยสำหรับพื้นที่ผู้ใช้
2. จากntsd notepad:cs=001b ss=0023 ds=0023 es=0023

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

กระบวนการมีรหัสข้อมูลกองและกลุ่มสแต็ก ตอนนี้ Instruction Pointer (IP) ของเธรดหรือเธรดจะชี้ไปที่ส่วนรหัสของกระบวนการ กลุ่มข้อมูลและฮีปร่วมกันโดยเธรดทั้งหมด แล้วพื้นที่สแต็คล่ะ พื้นที่สแต็กคืออะไร? มันเป็นพื้นที่ที่สร้างโดยกระบวนการเพียงเพื่อให้เธรดใช้ ... เนื่องจากสแต็กสามารถใช้ในวิธีที่เร็วกว่าฮีปเป็นต้นพื้นที่สแต็กของกระบวนการจะแบ่งระหว่างเธรดเช่นถ้ามี 3 เธรด พื้นที่สแต็กของกระบวนการแบ่งออกเป็น 3 ส่วนและแต่ละส่วนจะถูกกำหนดให้กับ 3 เธรด กล่าวอีกนัยหนึ่งเมื่อเราบอกว่าแต่ละเธรดมีสแต็กของตัวเองสแต็กนั้นเป็นส่วนหนึ่งของพื้นที่สแต็กกระบวนการที่จัดสรรให้กับแต่ละเธรด เมื่อเธรดเสร็จสิ้นการประมวลผลสแต็กของเธรดจะถูกเรียกคืนโดยกระบวนการ ในความเป็นจริง, ไม่เพียง แต่สแต็คของกระบวนการจะถูกแบ่งระหว่างเธรด แต่ชุดของรีจิสเตอร์ทั้งหมดที่เธรดใช้เช่น SP, PC และการลงทะเบียนสถานะเป็นการลงทะเบียนของกระบวนการ ดังนั้นเมื่อพูดถึงการแชร์โค้ดข้อมูลและพื้นที่ฮีปจะถูกแชร์ในขณะที่พื้นที่สแต็กจะถูกแบ่งระหว่างเธรด

เธรดใช้รหัสและส่วนข้อมูลร่วมกันและฮีป แต่จะไม่แชร์สแต็ก

เธรดใช้ข้อมูลและรหัสร่วมกันในขณะที่กระบวนการไม่ทำ สแต็กไม่ถูกแชร์สำหรับทั้งคู่

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

           ด้ายกระบวนการ

   กองส่วนตัวส่วนตัว
   แบ่งปันข้อมูลส่วนตัว
   รหัสส่วนตัว1 ที่   แชร์2

¹รหัสเป็นแบบส่วนตัวตามหลักเหตุผลแต่อาจใช้ร่วมกันด้วยเหตุผลด้านประสิทธิภาพ ²ฉันไม่แน่ใจ 100%

กระทู้แบ่งปันทุกอย่าง [1] มีพื้นที่ที่อยู่หนึ่งรายการสำหรับกระบวนการทั้งหมด

แต่ละเธรดมีสแต็กและการลงทะเบียนของตัวเอง แต่สแต็กทั้งหมดของเธรดจะปรากฏในพื้นที่ที่อยู่ที่ใช้ร่วมกัน

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

อันที่จริงผมเพิ่งสังเกตเห็นปัญหาที่กว้างขึ้น: ฉันคิดว่าคุณกำลังสับสนสองใช้คำว่าส่วน

รูปแบบไฟล์สำหรับไฟล์เรียกทำงาน (เช่น ELF) มีส่วนที่แตกต่างกันซึ่งอาจเรียกว่าเซ็กเมนต์ประกอบด้วยรหัสที่รวบรวม (ข้อความ) ข้อมูลเริ่มต้นสัญลักษณ์เชื่อมโยงข้อมูลการแก้ปัญหา ฯลฯ ไม่มีกองหรือสแต็กกลุ่ม ที่นี่เนื่องจากเป็นโครงสร้างแบบรันไทม์เท่านั้น

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

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

[1] ตกลงฉันรู้ว่า: มาสก์สัญญาณ, TSS / TSD เป็นต้นพื้นที่ที่อยู่รวมถึงเซ็กเมนต์โปรแกรมที่แมปทั้งหมดยังคงแชร์อยู่

ในเฟรมเวิร์ก x86 สามารถแบ่งเซ็กเมนต์ได้มากถึง 2 ^ 16-1 ASM directives SEGMENT / ENDS อนุญาตสิ่งนี้และโอเปอเรเตอร์ SEG และ OFFSET อนุญาตให้เริ่มต้นการลงทะเบียนเซ็กเมนต์ CS: IP มักจะเริ่มต้นได้โดยโหลดเดอร์ แต่สำหรับ DS, ES, SS แอปพลิเคชันมีหน้าที่รับผิดชอบในการเริ่มต้น สภาพแวดล้อมจำนวนมากอนุญาตให้เรียกว่า "คำจำกัดความเซ็กเมนต์ที่เรียบง่าย" เช่น. code, .data, .bss, .stack เป็นต้นและขึ้นอยู่กับ "โมเดลหน่วยความจำ" (เล็ก, ใหญ่, กะทัดรัด ฯลฯ ) ตัวโหลดเริ่มต้นการลงทะเบียนเซ็กเมนต์ ตาม โดยปกติแล้ว. data, .bss, .stack และกลุ่มอื่น ๆ ตามปกติ (ฉันไม่ได้ทำเช่นนี้มาตั้งแต่ 20 ปีแล้วดังนั้นฉันจำไม่ได้ทั้งหมด) จัดกลุ่มเป็นกลุ่มเดียว - นั่นคือเหตุผลที่ปกติ DS, ES และ SS ชี้ไปที่ teh พื้นที่เดียวกัน แต่นี่เป็นเพียงการทำให้สิ่งต่าง ๆ ง่ายขึ้น

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

คำแนะนำของฉันสำหรับคนหนุ่มสาว - อ่านหนังสือการเขียนโปรแกรมประกอบที่ดี ดูเหมือนว่าหลักสูตรของมหาวิทยาลัยนั้นค่อนข้างยากจนในแง่นี้

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

• ID กระบวนการและ ID กระบวนการหลัก
• ID กลุ่มกระบวนการและรหัสเซสชัน
• สถานีควบคุม
• ข้อมูลรับรองกระบวนการ (ID ผู้ใช้และกลุ่ม)
• ตัวอธิบายไฟล์แบบเปิด
• ล็อคบันทึกสร้างขึ้นโดยใช้ fcntl();
• การกำจัดสัญญาณ
• ข้อมูลที่เกี่ยวข้องกับระบบไฟล์: umask, ไดเรกทอรีทำงานปัจจุบันและไดเรกทอรีราก
• ตัวจับเวลาช่วงเวลา ( setitimer()) และตัวนับ POSIX ( timer_create());
• การส่งสัญญาณระบบ V ยกเลิกsemadjค่า () ค่า (มาตรา 47.8);
• ข้อ จำกัด ทรัพยากร
• เวลา CPU ที่ใช้ไป (ส่งคืนโดยtimes())
• ทรัพยากรที่ใช้ไป (ส่งคืนโดยgetrusage()) และ
• คุ้มค่า (กำหนดโดยsetpriority()และnice())

ระหว่างแอ็ตทริบิวต์ที่แตกต่างกันสำหรับแต่ละเธรดมีดังต่อไปนี้:

• ID เธรด (มาตรา 29.5);
• หน้ากากสัญญาณ
• ข้อมูลเฉพาะเธรด (ส่วน 31.3);
• สแต็กสัญญาณทางเลือก ( sigaltstack());
• ตัวแปร errno
• สภาพแวดล้อมจุดลอยตัว (ดูfenv(3));
• นโยบายการจัดตารางเวลาแบบเรียลไทม์และลำดับความสำคัญ (ส่วน 35.2 และ 35.3);
• CPU affinity (เฉพาะ Linux, อธิบายไว้ในส่วน 35.4);
• ขีดความสามารถ (เฉพาะ Linux, อธิบายไว้ในบทที่ 39); และ
• stack (ตัวแปรโลคัลและข้อมูลการเชื่อมโยงการเรียกใช้ฟังก์ชัน)

ข้อความที่ตัดตอนมาจาก: ส่วนต่อประสานการเขียนโปรแกรม Linux: คู่มือการเขียนโปรแกรมระบบ Linux และ UNIX, Michael Kerrisk , หน้า 619

เธรดแชร์ฮีป (มีการวิจัยเกี่ยวกับฮีปเฉพาะเธรด) แต่การใช้ปัจจุบันใช้ฮีปร่วมกัน (และแน่นอนรหัส)

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

ดังนั้น ans ของคุณควรเป็นหน่วยความจำฮีปที่เธรดทั้งหมดแชร์สำหรับกระบวนการ