Singleton Class ใน Java - จะใช้ Singleton Class ได้อย่างไร?

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

ด้านล่างนี้เป็นหัวข้อที่ฉันจะกล่าวถึงในบทความนี้:

pass by value vs pass โดยอ้างอิง java

• Singleton Class ใน Java คืออะไร?
• วิธีออกแบบ Java Singleton Class
  1. วิธีการเริ่มต้นอย่างกระตือรือร้น
  2. วิธีการเริ่มต้นขี้เกียจ
  3. เธรดปลอดภัย Singleton วิธี
  4. การเริ่มต้นขี้เกียจด้วยวิธี Double Lock
  5. ขี้เกียจโหลดวิธี
  6. วิธีการเริ่มต้นบล็อกแบบคงที่

มาเริ่มกันเลย.

Singleton Class ใน Java คืออะไร?

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

แต่ทำไมเราถึงต้องการคลาส Singleton ตั้งแต่แรก?

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

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

วิธีออกแบบ Java Singleton Class

ในการสร้างคลาสซิงเกิลใน Java คุณต้องมีสามสิ่งต่อไปนี้:

1. สมาชิกคงที่ของคลาส
2. ตัวสร้างส่วนตัว
3. วิธีโรงงานแบบคงที่

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

1. วิธีการเริ่มต้นอย่างกระตือรือร้น
2. วิธีการเริ่มต้นขี้เกียจ
3. เธรดปลอดภัย Singleton วิธี
4. การเริ่มต้นขี้เกียจด้วยวิธี Double Lock
5. ขี้เกียจโหลดวิธี
6. วิธีการเริ่มต้นบล็อกแบบคงที่

ตอนนี้เรามาเจาะลึกเกี่ยวกับวิธีการเหล่านี้ทีละวิธีกัน

1. วิธีการเริ่มต้นอย่างกระตือรือร้น

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

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

ตอนนี้เรามาดูวิธีการนำไปใช้กัน

// Eager Initialization public class EagerSingleton {private static final EagerSingleton INSTANCE = new EagerSingleton () private EagerSingleton () {} public static EagerSingleton getInstance () {return INSTANCE}}

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

ดังนั้นเรามาดูอีกวิธีในการสร้างคลาสซิงเกิลตันใน Java

2. ขี้เกียจวิธีการเริ่มต้น

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

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

โค้ดด้านล่างแสดงวิธีการดำเนินการนี้.

// LazySingleton public class LazySingleton {private static LazySingleton INSTANCE = null private LazySingleton () {} public static LazySingleton getInstance () {if (INSTANCE == null) {synchronized (LazySingleton.class) {INSTANCE = new LazySingleton ()}} ส่งคืน INSTANCE}}

3. เธรดปลอดภัย Singleton วิธี

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

// Thread Safe Singleton คลาสสาธารณะ ThreadSafeSingleton {ส่วนตัวคง ThreadSafeSingleton INSTANCE ส่วนตัว ThreadSafeSingleton () {} ThreadSafeSingleton ที่ซิงโครไนซ์แบบคงที่สาธารณะ getInstance () {if (INSTANCE == null) {INSTANCE = new ThreadSafeSingleton ()} ส่งคืน INSTANCE}}

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

4. ขี้เกียจเริ่มต้นด้วย Double Lock วิธี

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

วิธีสร้างเซสชันใน java

// Lazy Initialization ด้วย Double Lock คลาสสาธารณะ LazyDoubleLockSingleton {private static LazyDoubleLockSingleton INSTANCE = null private LazyDoubleLockSingleton () {} public static LazyDoubleLockSingleton getInstance () {if (INSTANCE == null) {synchronized (LazyDoubleLockSingleton INclass) {if (INSTANCE == null) {synchronized (LazyDoubleLockSingleton INclass) null) {INSTANCE = new LazyDoubleLockSingleton ()}} คืน INSTANCE}}

5. ขี้เกียจโหลดวิธี

วิธีนี้ขึ้นอยู่กับ JSL (Java Language Specification) และตามนี้ จะโหลดสมาชิกข้อมูลแบบคงที่เมื่อจำเป็นเท่านั้น ดังนั้นเมื่อโหลดคลาส singleton ของคุณลงใน JVM จะไม่มีการสร้างอินสแตนซ์ นอกจากนี้ในระหว่างการดำเนินการของโปรแกรมจะมีการเรียกใช้ global method ตามลำดับ ด้วยวิธีนี้คุณไม่จำเป็นต้องซิงโครไนซ์ getInstance () แบบคงที่อย่างชัดเจนเพื่อโหลดและเริ่มต้น สมาชิกคลาสแบบคงที่จะถูกเรียกใช้ในลักษณะที่เรียงตามลำดับที่เหมาะสมส่วนที่เหลือของการเรียกใช้เมธอดโกลบอลพร้อมกันจะถูกส่งคืนในลำดับเดียวกันโดยไม่ต้องทำการซิงโครไนซ์เหนือศีรษะ

ด้านล่างนี้คือรหัสสำหรับการดำเนินการเดียวกัน

// LazyLoadSingleton คลาสสาธารณะแบบ LazyLoadSingleton {private LazyLoadSingleton () {} คลาสคงที่ส่วนตัว SingletonClassHolder {static final Var INSTANCE = new LazyLoadSingleton ()} public static LazyLoadSingleton getInstance () {return SingletonClassHolder.INSTANCE}}

6. วิธีการเริ่มต้นบล็อกแบบคงที่

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

// Static Block Initialization public class StaticBlockSingleton {private static StaticBlockSingleton INSTANCE private StaticBlockSingleton () {} // ข้อยกเว้นการจัดการภายใน static block static {try {INSTANCE = new StaticBlockSingleton ()} catch (Exception e) {throw new RuntimeException ('Exception เกิดขึ้น ในขณะที่สร้างคลาส Singleton ')}} StaticBlockSingleton แบบคงที่สาธารณะ getInstance () {return INSTANCE}}

เรามาถึงตอนท้ายของบทความนี้เกี่ยวกับคลาส Singleton ใน Java หากคุณต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับ Java คุณสามารถอ้างถึงไฟล์ .

ตอนนี้คุณเข้าใจแล้วว่าคลาส Singleton ใน Java คืออะไรลองดูไฟล์ โดย Edureka บริษัท การเรียนรู้ออนไลน์ที่เชื่อถือได้ซึ่งมีเครือข่ายผู้เรียนที่พึงพอใจมากกว่า 250,000 คนกระจายอยู่ทั่วโลก หลักสูตรการฝึกอบรมและการรับรอง Java J2EE และ SOA ของ Edureka ออกแบบมาสำหรับนักเรียนและผู้เชี่ยวชาญที่ต้องการเป็น Java Developer หลักสูตรนี้ออกแบบมาเพื่อให้คุณเริ่มต้นการเขียนโปรแกรม Java และฝึกอบรมแนวคิด Java ทั้งหลักและขั้นสูงพร้อมกับเฟรมเวิร์ก Java ต่างๆเช่น Hibernate & Spring

มีคำถามสำหรับเรา? โปรดระบุไว้ในส่วนความคิดเห็นของบทความ 'Singleton Class in Java' และเราจะติดต่อกลับโดยเร็วที่สุด