Table of Contents

מבוא

דפוס ה- Singleton היה אבן הפינה של דיונים הנדסיים תוכנה במשך עשרות שנים.הבטחה שלה - מקרה יחיד, נגיש בעולם של מעמד - הוא פשוט מאוד.אבל לאורך השנים, מפתחים גם חגגו וביקרו אותו.כאשר השתמשו נכון, Singletons לנהל משאבים משותפים אלגנטיים כמו מנהלי תצורה, שירותי תצורה, או בריכות חיבור.

מהו ה- Singleton Pattern?

דפוס ה- Singleton שייך ל-FLT:0 תבניות עיצוב של יצירה (FLT) למשפחה 1:1.

  1. שיעור אחד יכול להיות (ה- 0) רק מקרה אחד של 1 (החליפ) בכל אורך החיים של היישום ו- #8217.
  2. כך צריך להיות (ב) מ-[[1924]], [[1924]], [[1924]], [[1924]], [[1924]]]], [[1924]]]]
  3. השיעור עצמו חייב להיות (ה- 0) לשלוט על הרגעה שלו:1, למנוע קוד חיצוני ליצור עותקים נוספים.

מטרות אלה מושגות על ידי הפיכת הבניין פרטי ומספק שיטה סטטית (לעתים קרובות בשם FLT:0) אשר מחזירה את המקרה היחיד.הקריאה הראשונה לאותה שיטה יוצרת את האובייקט; כל שיחה לאחר מכן מחזירה את ההתייחסות המצופה.

למה מפתחים מגיעים ל- Singletons

הסינגלים פותרים בעיה חוזרת: להבטיח שהמשאב ש-FLT:0.03.1 יהיה ייחודי למעשה.

  • חיבורים:0Database: FigFLT:1; A One Connection Pool נמנעים ממשאבים מוגבלים של מסד נתונים.
  • (ב) ,0) קבצים מצורפים: 1FLT:1 טעינה הגדרות פעם אחת ושיתוף אותם מונעים ערך I/O ו- Inconsistency.
  • (ב) ⁇ :0) שירותים: 1 (בקיצור: 1) ⁇ מרכזי מבטיח סדר דטרמיוני ואין קונפליקטים של קבצים.
  • (FLT:0) נהגי ההדרה: 1FLT:1 ממשקים ברמה נמוכה כמו מדפסת spooler או נהג GPU לא יכול לסבול מקרים משוכפלים.

היסטוריה קצרה של ה- Singleton Pattern

דפוס ה- Singleton תועדו באופן רשמי על ידי האנג' של ארבעה (GoF) בספרם משנת 1994 (FLT:0Design Patterns: Elements of Reusable Object-Oriented SoftwareveFLT:1 עם זאת, הרעיון הבסיסי של הטורף שפרסמה בשנים רבות - פרוגרמה נעשו יישום ו-#82; אחד-of-of-of-a-kind R אובייקטים מאז ימי קדם של תכנות, סיפקו-Fified, הואשמו של , הואשמו של יישם ו-Fified, ו-Fified, ו-Fified, ו-Fified, אשר היה יישום, ו-Fified, אשר היה , ו-Fified, אשר היה , ו-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of-of

בסוף שנות ה-90 ובתחילת שנות ה-2000, הסינגלונים הפכו כמעט לתבנית ברירת מחדל לניהול המדינה העולמית.מסגרות כמו Java ’ באביב מאוחר יותר לערער על הגישה הזו על ידי קידום הזרקת התלות וההסתירה של שליטה כאלטרנטיבה גמישה יותר.הדיון ממשיך היום: רווקים אינם רעים מטבעם, אך יש להשתמש בהם במודעות לתופעות הלוואי שלהם.

המונחים: Singleton Implementation

שום יישום יחיד אינו פועל עבור כל השפות ומודלים של קונפדרציונאליים להלן הם הווריאציות הנפוצות ביותר, כל אחד עם הרכישות שלו.

◄

המקרה נוצר כאשר השיעור טעון, לפני שכל קוד קורא ל-FLT:1 (זה פשוט ותמציתי חסום-בטוח בשפות רבות (למשל, ראשי תיבות סטטיים בג'אווה מובטחים לרוץ פעם אחת).

public class Singleton {
 private static final Singleton INSTANCE = new Singleton();
 private Singleton() {}
 public static Singleton getInstance() {
 return INSTANCE;
 }
}

Lazy Preization (Thread-Safe with Double-Checked Locking)

כדי להימנע יצירת המקרה עד שהוא באמת נחוץ, הזייף העצלן מתפזר בנייה.בסביבות מרובות-הנקראות, דפוס נעילה כפול-מבוד קלאסי מונע תנאים גזע תוך צמצום הסינכרון מעל הראש:

public class Singleton {
 private static volatile Singleton instance;
 private Singleton() {}
 public static Singleton getInstance() {
 if (instance == null) {
 synchronized (Singleton.class) {
 if (instance == null) {
 instance = new Singleton();
 }
 }
 }
 return instance;
 }
}

מילת המפתח (ב- Java) מונעת תיקון הוראה שיכול לגרום לאובייקט שנבנה באופן חלקי כדי להחזיר אותו.תבנית זו בטוחה אך פועלית – חלופות מודרניות קיימות לעיתים קרובות.

ביל פוטון (Initialization-on-Demand Holder Idiom)

גישה זו ספציפית Java ממנת את ההבטחה כי מעמד פנימי סטטי אינו טעון עד שהוא מתייחס.זה משלב אמפתיה עצלנית עם בטיחות חוט ללא סינכרוניזציה מפורשת:

public class Singleton {
 private Singleton() {}
 private static class Holder {
 private static final Singleton INSTANCE = new Singleton();
 }
 public static Singleton getInstance() {
 return Holder.INSTANCE;
 }
}

Enum Singleton

ג'אווה מפתחת:0) ג'וישו בלוצ'רוב 1 (Joshua BlochFLT:1) , לפופולרית השימוש ב-FLT:6 כדי ליישם את הסינגלtons. גישה זו מספקת הגנה מפני השתקפות והתקפות הסדרתיות מתוך הקופסה:

public enum Singleton {
 INSTANCE;
 // add methods here
}

Enums הם סידוריים כברירת מחדל, ו- JVM מבטיח רק מקרה אחד קבוע. עבור מקרים רבים של שימוש ב- Java, זוהי הגישה הבטוחה והפשוטה ביותר.

Singleton ב- Python

Python ’ מערכת מודול מיושמת באופן טבעי את תבנית ה- Singleton: מודול מיובא רק פעם אחת, כך אובייקטים ברמת מודול מתנהגים כמו רווקות.

class Singleton:
 _instance = None
 def __new__(cls, *args, **kwargs):
 if cls._instance is None:
 cls._instance = super().__new__(cls)
 return cls._instance

Singleton in JavaScript (ES6)

ב- JavaScript המודרני, מודולים וסגרות מציעים יישום חד-טון נקי:

const Singleton = (function() {
 let instance;
 function createInstance() {
 return { id: Math.random() };
 }
 return {
 getInstance: function() {
 if (!instance) {
 instance = createInstance();
 }
 return instance;
 }
 };
})();

הפרקטיקה הטובה ביותר ליישום Singletons

יישום Singletons דורש יותר מאשר רק לעבור את קוד snippet.ההנחיות הבאות לעזור לך ליצור בודדונים חזקים ושמירה על.

1 תמיד לשקול את בטיחות

גם אם היישום שלך הוא כרגע יחיד מוכן, ערבויות על העתיד הם יקרים לעשות מאוחר יותר. השתמש בדפוסי ראשונית מאובטח חוט בטוח מההתחלה. ביל Pugh idiom (Java) או ראשונית להוטה (שם המשאב הוא זול) הם אפשרויות מוצקות.

2 הגנה מפני הרהורים ו Serialization

יישום סטנדרטי של טוטון יכול להישבר באמצעות השתקפות Java (הקריאה של הבונים הפרטיים) או באמצעות התפלה (שנונה מקרה חדש) כדי להגן מפני אלה:

  • (ב) ⁇ :0) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • (ב) ויקרא: ויקרא י"א): "הִנָּעָשָׂה אִתָּעָה אִתָּבְתָּעָה אִתָּעָה אִתָּתְתָּעָה" (בראשית כ"ד, כ"ד).

שמור על ה- Singleton Stateless בכל פעם שאפשר

סינגלים עם מדינה מסולפת הופכים למשתנים גלובליים משותפים.אם המדינה חיונית, לבדוק כי מעברי המדינה הם בטיחות חוט.איפה אפשרי, מעדיפים רווקות חד-פעמיות: הם בטוחים לחלוטין וקלים יותר להיגיון.

4.ספק ממשק נקי, לא מודע

חשיפה לטון באמצעות שיטה סטטית בשם בבירור, להימנע מחשיפת הדוגמא ישירות כתחום סטטי ציבורי; באמצעות מקדמה מעניקה לך את הגמישות לשנות את ההיגיון של הרגעה מאוחר יותר ללא שבירת לקוחות.

5.אל תתגבר על התבנית

Singletons מתאימים רק כאשר אתה באמת צריך מקרה אחד:0reaand 1 לדוגמה, למשל, דאגה חוצה חתומה.עבור שיטות שירות או פונקציות טהורות, שיטות סטטיות הן פשוטות יותר.

מלכודות נפוצות וכיצד להימנע מהם

אפילו מפתחים מנוסים נופלים למלכודת אלה, הכירו אותם מוקדם כדי לחסוך שעות מבוללות.

« « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « «

כאמור, השתקפות יכולה להפעיל בונה פרטי ב- Java, באפשרותך להוסיף שומר:

private Singleton() {
 if (INSTANCE != null) {
 throw new RuntimeException("Use getInstance() to obtain the singleton.");
 }
}

עדיף עדיין, להשתמש ב- enum Singleton - JVM חוסם השתקפות על enums.

פיט 2: Serialization יוצר מספר רב של אי-ספיקות

כאשר אחד מהם מיישם את שיטת ה-FLT:13, deserialization בונה אובייקט חדש, עקף את הבונים החופשיים.

protected Object readResolve() {
 return getInstance();
}

מלכוד 3: בעיות

בסביבות כמו Java EE יישומי שרתים, מספר רב של משאיות יכול לטעון את הכיתה הבודדטון, וכתוצאה מכך מקרה אחד לעומס בכיתה.זה למעשה שובר את ערבות הטון.

  • באמצעות רישום סטטי או נכס מערכת כדי לאכוף נהג אחד.
  • הבטחת שיעור הטון עמוסה על ידי נהג משותף (הורה).

מלכוד 4: קוד חזק וקשה

קוד המכונים (FLT:16 ישירות יחד עם שיעור קונקרטי זה.לקבוע את הטון עם לעג או סטב עבור בדיקות יחידה הופך כמעט בלתי אפשרי.FLT:0Solution: EvolutionFLT:1 תוכנית לממשק ולהזריק את הטון דרך מסגרת או מפעל.

מלכוד 5: המדינה העולמית והתלויים הנסתרים

(המתונים מתנהגים כמו משתנים גלובליים.לאורך זמן, כל שיטה בכל מחלקה יכולה לקרוא ל-FLT:17, יצירת עכביש של תלות נסתרת.זה הופך את הקוד קשה יותר להבין, לדה-בגד ולתחזק.

« « « ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇

היפנוזה עצלנית ללא סינכרון יכולה לגרום לשני חוטים ליצור שני מקרים שונים, מפרה את התבנית.תבנית נעילה כפולה שנראתה מוקדם יותר בטוח רק כאשר מיושמת כראוי (לא יעיל, סדר נכון) בשפות רבות, דפוסים פשוטים ובטוחים יותר קיימים - מאשר אותם.

בדיקות Singletons

קוד בדיקה המשתמש ב-Stetons הוא מסובך לשמצה.הגישה הקלאסית היא לספק את ה-oneton להשתמש בממשק ובמפעל, ולאחר מכן להזריק מקרה לעג במהלך בדיקות.לדוגמה, במקום לקרוא ל-FLT:18, אתה מזריק ממשק FLT:19.קוד הייצור עובר את יישום ה-oneton; בדיקות לעבור לעג.

אם יש לשמור על הטון, טכניקה נוספת היא לנקות את המקרה בין בדיקות באמצעות שיטת איפוס חבילה-פרטיבית (רק למטרות בדיקה) כמה מסגרות, כמו FLT:0PowerMockirFLT:1 ב Java, לאפשר ללעג שיטות סטטיות, אך הן מגיעות עם ראש למעלה וצריכים להיות אתר נופש אחרון.

התשובה הנקייה ביותר היא: (FLT:0) ללא תכנון קוד, תלוי בעקרון בטון של יחידנים (FLT:1 ).

אפשרויות ל-oneton Pattern

לפני ביצוע יחידטון, לשקול חלופות אלה לעתים קרובות מניבות עיצוב טוב יותר.

שטף (DI) ו- Singleton Scope

מיכלי DI (Spring, Guice, Dagger) יכולים לנהל סינגלטון (FLT:0igscopeFLT:1 עבור אובייקט מסוים.השירות הוא מיידי על ידי מיכל וזרק לכל הלקוחות לעולם לא להתקשר (FLT:20), הם פשוט להכריז על תלות.זה מקלקל את הלקוח מן המעמד הבטון והופך בדיקות טריוויאליות - אתה להחליף את התצורה באמצעות לעג.

תבנית Monostate

דפוס Monostate לאכוף את ה-FLT:0 (חלקו של המדינה) במקום מקרה אחד.מספר מקרים של המעמד קיימים, אבל כולם חולקים את אותם שדות סטטיים, בעוד זה נמנע מ- “ גלובל טוטון & #8221; סטיגמה, היא עדיין מציגה מדינה גלובלית ויכולה להיות מבלבלת כי FLT:21 נראה כמו אובייקט רגיל אבל מתנהג אחרת.

Static Class או מודול

אם “ Singleton ” הוא רק אוסף של שיטות ללא תנאי, שיעור סטטי (Java) או מודול (Python, JavaScript) הוא פשוט יותר ומפורט יותר.

Factory Pattern

כאשר אתה צריך לשלוט במספר המקרים, אבל גם רוצה להישאר גמיש (למשל, בריכות), מפעל מחזיר אותו מקרה הוא מופשט יותר מאשר מחלקה בטון.

Singleton Pattern in Modern Frameworks

מסגרות מודרניות רבות מרתיעות יישום חד-טון מפורש: לדוגמה:

  • (FLT:0)Spring Framework:FLT:1 Beans הם Singleton-scoped על ידי ברירת מחדל.You פשוט להגדיר שעועית פעם אחת, והמכל מבטיח מקרה אחד.מפתחים רק לעתים רחוקות לכתוב את הכיתה שלהם.
  • (FLT:0אנדרואיד) : ⁇ 1) משתמשים ב- Singletons עבור שירותי מערכת מסוימים, אבל ה- Android SDK מספק חיבור של 22FLT כתבנית קרטון בטוחה.
  • (ב) ⁇ :0 ⁇ ⁇ :0 ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇

מקרים שבהם Singletons Excel

למרות הביקורת, הטון הוא הבחירה הנכונה בתרחישים מסוימים:

  • (ב) ויקרא י"ד: ויקרא י"ד: "ה', ויקרא י"ד, ויקרא י"ד, י"ד).
  • מקור יחיד להגדרה (ב"א)
  • (ב) ,0) ,9 ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇
  • (ב) ,0) ממשקי חומרה (FLT:1) - טיפול יחיד עבור מכשיר פיזי.
  • (ב) ,0) מנהלי המפלגה (FLT:1) - כאב חד-ימי כדי להימנע משכפול.

בכל מקרה, הטון אינו פשע עיצוב, אלא החלטה ארכיטקטונית מכוונת.המפתח הוא לבודד את הטון מאחורי ממשק כך שלקוחות אינם קשורים ליישום קונקרטי.

מסקנה

דפוס ה- Singleton נותר כלי יקר במהנדס התוכנה & #8217; ערכת הכלים, אבל זה חייב להיות מופעל בזהירות.כוחו הוא להבטיח מקרה אחד ולספק נקודת גישה גלובלית - שני נכסים אשר, כאשר בשילוב, יכול בקלות להציג את המדינה העולמית, הפיכה הדוקה, ובדיקת חסמים חד-פעמיים יותר.

לקריאה נוספת, התייחסה למאמר הקלאסי של ה-FLT:0 (Wikipedia) על דפוס ה- Singleton PatternsFLT:1, הדיון מעמיק ב-FLT:2refactoring GurucioFLT 3, ו- Martin Fowler & #8217; ניתוח תובנות על FLT:4lers של Enterprise Applications:5: