TechAlpine – All About Technology

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

การแนะนำ:
JVM ที่แบ่งหน่วยความส่วนต่อไปนี้:

• กอง: ส่วนนี้ประกอบด้วยวัตถุและตัวแปรอ้างอิง.
• กอง: ในส่วนนี้จะมีวิธีการ, ตัวแปรและตัวแปรอ้างอิงในท้องถิ่น.
• Code: ส่วนนี้ประกอบด้วยรหัสไบต์.
• Static: ในส่วนนี้จะมีตัวแปรคงที่และวิธีการ.

ใน Java, เราสามารถประกาศตัวแปรในต่อไปนี้สามมารยาท:

• ตัวแปรเช่น.
• ระดับชั้นเรียนหรือตัวแปรคงที่.
• ตัวแปรท้องถิ่นหรือสแต็ค.

ตัวแปรเช่น: ตัวแปรเช่นแสดงให้เห็นว่าพวกเขามีอยู่ต่อตัวอย่างของชั้นเรียน. ถ้าชั้นมีสิบกรณี, เราจะมีสิบสำเนาของแต่ละตัวแปรเช่น. ตัวแปรเช่นจะเรียกว่ายังเป็นตัวแปรคงไม่ใช่.

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

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

pic1: การจัดจำหน่ายหน่วยความจำ Java

ให้เราดูต่อไปนี้สามรหัสชวา

Listing 1: การเข้าถึงตัวแปรสแต็ค:

[Code]

com.home.variables แพคเกจ;

StackVariables เรียนสาธารณะ {

// การเข้าถึงไปยังกองตัวแปร

stackAccess โมฆะสาธารณะ(int mAXVAL) {

int J = 0;

สำหรับ (int i = 0; ผม < Val; i ) {

J = 1;

}

}

}

[/Code]

Listing 2: การเข้าถึงตัวแปรเช่น

[Code]

com.home.variables แพคเกจ;

InstanceVariables เรียนสาธารณะ {

instVar int ส่วนตัว;

//การเข้าถึงตัวแปรเช่นชั้น

instanceAccess โมฆะสาธารณะ(int Val) {

สำหรับ (int i = 0; ผม < Val; i ) {

instVar = 1;

}

}

}

[/Code]

Listing 3: การเข้าถึงตัวแปรคง

[Code]

com.home.variables แพคเกจ;

StaticVariables เรียนสาธารณะ {

ส่วนตัว staticVar int คงที่;

//ระดับการเข้าถึงตัวแปรคงที่

staticAccess โมฆะสาธารณะ(int Val) {

สำหรับ (int i = 0; ผม < Val; i ) {

staticVar = 1;

}

}

}

[/Code]

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

ตัวแปรระดับอินสแตนซ์และตัวแปรคงใช้เงินจำนวนเดียวกันเกือบของเวลาที่จะดำเนินการ. ในขณะที่ตัวแปรท้องถิ่นหรือสแต็คเป็น 2-3 ครั้งได้เร็วขึ้น. ในกรณีของตัวแปรท้องถิ่นหรือสแต็ค, ตั้งแต่ JVM มีการดำเนินการน้อยกว่าเมื่อมีการเข้าถึงแบบคงที่หรือระดับชั้นเรียนหรือตัวแปรระดับอินสแตนซ์. รหัสต่อไปนี้ไบต์สร้างทำให้มันชัดเจน:

Listing 4: รหัสไบต์สร้างขึ้นกับรายชื่อ 1 (การเข้าถึงสแต็ค)

[Code]

วิธีโมฆะ stackAccess(int)

0 iconst_0 // กด 0 บนสแต็ค.

1 istore_2 // ป๊อป 0 และเก็บไว้ที่ดัชนี 2 ของตารางตัวแปรท้องถิ่น(j).

2 iconst_0 // กด 0.

3 istore_3 // ป๊อป 0 และเก็บไว้ที่ดัชนี 3 ของตารางตัวแปรท้องถิ่น(ผม).

4 ไปที่ 13 //ข้ามไปยังตำแหน่ง 13.

7 iinc 2 1 //เพิ่ม J บันทึกอยู่ในดัชนี 2 by 1.

10 iinc 3 1 //เพิ่มขึ้นผมเก็บไว้ที่ดัชนี 3 by 1.

13 iload_3 // ผลักดันมูลค่าดัชนี 3(ผม).

14 iload_1 // ผลักดันมูลค่าดัชนี 1(Val).

15 if_icmplt 7 //Pop ฉันและวาล. ข้ามไปยังตำแหน่ง 7 ถ้าฉันมีค่าน้อยกว่า Val.

18 ผลตอบแทน // กลับไปใช้วิธีการโทร.

[/Code]

Listing 5: รหัสไบต์สร้างขึ้นกับรายชื่อ 2 (อินสแตนซ์หรือระดับชั้นการเข้าถึง)

[Code]

วิธีโมฆะ instanceAccess(int)

0 iconst_0 // กด 0 บนสแต็ค.

1 istore_2 // ป๊อป 0 และเก็บไว้ที่ดัชนี 2 ของตารางตัวแปรท้องถิ่น(ผม).

2 ไปที่ 18 //ข้ามไปยังตำแหน่ง 18.

5 aload_0 // ผลักดันดัชนี 0(นี้).

6 dup // ซ้ำค่าสแต็คชั้นนำและผลักดันมัน.

7 getfield #19 <สนาม instVar int>

//ป๊อปอ้างอิงวัตถุนี้และผลักดันค่าสำหรับ instVar.

10 iconst_1 // กด 1.

11 iadd // Pop ด้านบนสองค่า, ผลักดันผลรวมของพวกเขา.

12 putfield #19 <สนาม instVar int>

//Pop ด้านบนสองค่าและเก็บผลรวมใน instVar.

15 iinc 2 1 //เพิ่มขึ้นผมเก็บไว้ที่ดัชนี 2 by 1.

18 iload_2 // ผลักดันมูลค่าดัชนี 2(ผม).

19 iload_1 // ผลักดันมูลค่าดัชนี 1(Val).

20 if_icmplt 5 //Pop ฉันและวาล. ข้ามไปยังตำแหน่ง 5 ถ้าฉันมีค่าน้อยกว่า Val.

23 ผลตอบแทน // กลับไปใช้วิธีการโทร.

[/Code]

Listing 6: รหัสไบต์สร้างขึ้นกับรายชื่อ 6 (การเข้าถึงแบบคงที่)

[Code]

วิธีโมฆะ staticAccess(int)

0 iconst_0 // กด 0 บนสแต็ค.

1 istore_2 // ป๊อป 0 และเก็บไว้ที่ดัชนี 2 ของตารางตัวแปรท้องถิ่น(ผม).

2 ไปที่ 16 //ข้ามไปยังตำแหน่ง 16.

5 getstatic #25 <สนาม staticVar int>

//ผลักดันค่าจากสระว่ายน้ำคงที่สำหรับ staticVar.

8 iconst_1 // กด 1.

9 iadd // Pop ด้านบนสองค่า, ผลักดันผลรวมของพวกเขา.

10 putstatic #25 <สนาม staticVar int>

//ป๊อปอัพค่าสำหรับผลรวมและเก็บไว้ใน staticVar.

13 iinc 2 1 //เพิ่มขึ้นผมเก็บไว้ที่ดัชนี 2 by 1.

16 iload_2 // ผลักดันมูลค่าดัชนี 2(ผม).

17 iload_1 // ผลักดันมูลค่าดัชนี 1(Val).

18 if_icmplt 5 //Pop ฉันและวาล. ข้ามไปยังตำแหน่ง 5 ถ้าฉันมีค่าน้อยกว่า Val.

21 ผลตอบแทน // กลับไปใช้วิธีการโทร.

[/Code]

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

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

Listing 7: วิธีการปรับโครงสร้างหนี้ในการเข้าถึงตัวแปรเช่น

[Code]

com.home.variables แพคเกจ;

InstanceVariables เรียนสาธารณะ {

instVar int ส่วนตัว;

//การเข้าถึงตัวแปรเช่นชั้น

instanceAccess โมฆะสาธารณะ(int Val) {

int J = instVar;

สำหรับ (int i = 0; ผม < Val; i ) {

J = 1;

}

instVar = J;

}

}

[/Code]

Listing 8: การปรับโครงสร้างหนี้วิธีการเข้าถึงตัวแปรคง

[Code]

com.home.variables แพคเกจ;

InstanceVariables เรียนสาธารณะ {

staticVar int ส่วนตัว;

//การเข้าถึงตัวแปรเช่นชั้น

instanceAccess โมฆะสาธารณะ(int Val) {

int J = staticVar;

สำหรับ (int i = 0; ผม < Val; i ) {

J = 1;

}

staticVar = J;

}

}

[/Code]

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

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

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

• JVM แบ่งหน่วยความส่วนต่อไปนี้ :กอง, กอง, รหัสและแบบคงที่
• Java ช่วยให้เราสามารถประกาศตัวแปรในต่อไปนี้สามวิธี:
  • ตัวอย่าง
  • Static
  • ท้องถิ่นหรือสแต็ค.
• ใช้ตัวแปรระดับกองเร่งการทำงานของโปรแกรมโดย 2-3 ครั้ง.
• หากต้องใช้แบบคงที่หรือตัวแปรระดับอินสแตนซ์, เราควรจะคัดลอกไปยังตัวแปรท้องถิ่นก่อนที่จะจัดการกับข้อมูลหรือการทำการดำเนินการบางอย่าง.