ทำไมหนังสือ. Net พูดถึงการจัดสรรหน่วยความจำ stack vs heap

ดูเหมือนว่าหนังสือ. net ทุกเล่มจะพูดถึงประเภทค่าเทียบกับประเภทการอ้างอิงและทำให้เป็นจุด (มักจะไม่ถูกต้อง) ซึ่งเป็นที่เก็บแต่ละประเภท - กองหรือกองซ้อน โดยปกติจะอยู่ในบทแรก ๆ และนำเสนอเป็นข้อเท็จจริงที่สำคัญบางอย่าง ฉันคิดว่ามันครอบคลุมแม้ในการสอบรับรอง ทำไม stack vs heap ถึงสำคัญสำหรับนักพัฒนา. net คุณจัดสรรสิ่งของและใช้งานได้ใช่ไหม

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

ดังที่เฟดชี้ให้เห็น Eric Lippert มีบางสิ่งที่น่าสนใจมาก ๆ ที่จะพูดเกี่ยวกับสิ่งนี้: http://blogs.msdn.com/b/ericlippert/archive/2010/09/30/the-truth-about-value-types.aspx .

ในแง่ของข้อมูลคุณสามารถปรับย่อหน้าแรกของฉันให้อ่านโดยทั่วไป: "เหตุผลที่ผู้คนใส่ข้อมูลนี้และคิดว่ามันสำคัญเพราะข้อมูลที่ไม่ถูกต้องหรือไม่ครบถ้วนรวมกับความต้องการความรู้นี้ในอดีต"

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

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

ฉันเห็นด้วยอย่างสมบูรณ์ ฉันเห็นสิ่งนี้ตลอดเวลา

เหตุใดหนังสือ. NET จึงพูดถึงการจัดสรรหน่วยความจำแบบกองซ้อนกับกองซ้อน?

สาเหตุส่วนหนึ่งเป็นเพราะคนจำนวนมากมาที่ C # (หรือภาษา. NET อื่น ๆ ) จากพื้นหลัง C หรือ C ++ เนื่องจากภาษาเหล่านั้นไม่ได้บังคับใช้กฎของคุณเกี่ยวกับอายุการเก็บข้อมูลคุณจึงจำเป็นต้องรู้กฎเหล่านั้นและใช้โปรแกรมของคุณอย่างระมัดระวังเพื่อติดตาม

ตอนนี้การรู้กฎเหล่านั้นและติดตามพวกมันใน C ไม่ต้องการให้คุณเข้าใจ "ฮีป" และ "สแต็ก" แต่ถ้าคุณเข้าใจว่าโครงสร้างข้อมูลทำงานอย่างไรมันก็มักจะง่ายต่อการเข้าใจและปฏิบัติตามกฎ

เมื่อเขียนหนังสือมือใหม่มันเป็นเรื่องธรรมดาที่ผู้เขียนจะอธิบายแนวคิดในลำดับเดียวกันกับที่พวกเขาเรียนรู้ นั่นไม่จำเป็นต้องเป็นคำสั่งที่สมเหตุสมผลสำหรับผู้ใช้ เมื่อไม่นานมานี้ฉันเป็นบรรณาธิการด้านเทคนิคสำหรับหนังสือผู้เริ่มต้น C # 4 ของ Scott Dorman และหนึ่งในสิ่งที่ฉันชอบก็คือ Scott เลือกเรียงลำดับหัวข้อที่ค่อนข้างสมเหตุสมผลแทนที่จะเริ่มหัวข้อการจัดการหน่วยความจำขั้นสูง

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

ทำไม stack vs heap ถึงสำคัญสำหรับนักพัฒนา. NET

ในความคิดของฉันมันไม่ได้ สิ่งที่สำคัญกว่าที่จะเข้าใจก็คือ:

• ความแตกต่างในความหมายของการคัดลอกระหว่างประเภทอ้างอิงและประเภทค่าคืออะไร?
• พารามิเตอร์ "ref int x" ทำงานอย่างไร
• เหตุใดค่าประเภทจึงไม่เปลี่ยนรูป

และอื่น ๆ

คุณจัดสรรสิ่งของและใช้งานได้ใช่ไหม

นั่นคืออุดมคติ

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

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

แต่นั่นเป็นสถานการณ์ขั้นสูงทั้งหมด โปรแกรมเมอร์ที่เริ่มต้นนั้นไม่จำเป็นต้องกังวลเกี่ยวกับสิ่งนี้เลย

พวกคุณทุกคนหายจุด เหตุผลที่แตกต่างแต็ค / กองเป็นสิ่งสำคัญเป็นเพราะขอบเขต

struct S { ... }

void f() {
    var x = new S();
    ...
 }

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

class C { ... }

void f() {
     var x = new C();
     ...
}

เรื่องราวที่แตกต่างกันโดยสิ้นเชิง! เนื่องจาก x อยู่ในheapวัตถุของมัน (นั่นคือวัตถุเองไม่ใช่สำเนาของมัน) สามารถดำเนินชีวิตต่อไปได้ดีหลังจากxหมดขอบเขต ในความเป็นจริงวิธีเดียวที่มันจะไม่ดำเนินต่อไปคือถ้าxเป็นข้อมูลอ้างอิงเท่านั้น หากการมอบหมายหรือการเรียกใช้เมธอดในส่วน "... " ได้สร้างการอ้างอิงอื่น ๆ ที่ยังคง "สด" ตามเวลาที่xหมดขอบเขตแล้ววัตถุนั้นจะยังคงอยู่ต่อไป

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

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

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

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

ฉันไม่รู้เกี่ยวกับ. NET แต่เท่าที่ฉันรู้ JITted มันก่อนที่จะดำเนินการ ตัวอย่างเช่น JIT สามารถทำการวิเคราะห์การหลบหนีและสิ่งที่ไม่และในทันใดคุณจะต้องมีวัตถุวางอยู่บนกองซ้อนหรือเพียงแค่ในการลงทะเบียนบางอย่าง คุณไม่สามารถรู้สิ่งนี้

ฉันคิดว่าหนังสือบางเล่มครอบคลุมเพียงเพราะผู้แต่งให้ความสำคัญกับมันมากหรือเพราะพวกเขาคิดว่าผู้ชมของพวกเขาทำ (เช่นถ้าคุณเขียน "C # สำหรับโปรแกรมเมอร์ C ++" คุณน่าจะครอบคลุมหัวข้อ)

อย่างไรก็ตามฉันคิดว่าไม่มีอะไรจะพูดมากไปกว่า "การจัดการหน่วยความจำ" มิฉะนั้นผู้คนอาจวาดข้อสรุปที่ผิด

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

อาจมีบางกรณีขอบที่สามารถสร้างความแตกต่าง พื้นที่สแต็คเริ่มต้นคือ 1meg ในขณะที่ฮีปมีหลายกิ๊ก ดังนั้นหากคุณแก้ปัญหามีวัตถุจำนวนมากคุณสามารถใช้พื้นที่สแต็กในขณะที่มีพื้นที่จำนวนมาก

อย่างไรก็ตามส่วนใหญ่มันเป็นวิชาการที่สวย

อย่างที่คุณพูด C # ควรที่จะแยกการจัดการหน่วยความจำออกจากกันและการจัดสรรฮีปกับสแต็กเป็นรายละเอียดการใช้งานซึ่งตามทฤษฎีแล้วผู้พัฒนาไม่จำเป็นต้องรู้

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

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