דילוג לתוכן
  • דף הבית
  • קטגוריות
  • פוסטים אחרונים
  • משתמשים
  • חיפוש
  • חוקי הפורום
כיווץ
תחומים

תחומים - פורום חרדי מקצועי

💡 רוצה לזכור קריאת שמע בזמן? לחץ כאן!
  1. דף הבית
  2. תכנות
  3. נעילת קטע קריטי בקוד אסינכרוני

נעילת קטע קריטי בקוד אסינכרוני

מתוזמן נעוץ נעול הועבר תכנות
4 פוסטים 3 כותבים 220 צפיות
  • מהישן לחדש
  • מהחדש לישן
  • הכי הרבה הצבעות
התחברו כדי לפרסם תגובה
נושא זה נמחק. רק משתמשים עם הרשאות מתאימות יוכלו לצפות בו.
  • א מנותק
    א מנותק
    ארכיטקט
    כתב ב נערך לאחרונה על ידי
    #1

    שלום לכולם
    היו היו ימים טובים ועליזים שבהם הייתי נועל קטעים קריטיים (רוצה לומר: קוד שאסור שיפעל במקביל מ2 טרידים וכדומה כגון שהוא עשוי להוסיף 2 שורות לדטה בייס כאשר הבדיקה מתבצעת בתחילת הקטע וכן הלאה) ב C# על ידי מילת המפתח lock ומכניס לתוכה אובייקט כלשהו בהתאם לדרישה.
    אממה מאז שהעולם הפך אסינכרוני וכ 70% מהפונקציות הפכו לאסינכרוניות או בגלל מהותן, או בגלל שהן קוראות לפונקציות אסינכרוניות. הקסם של lock כבר לא קיים. אז מה האלטרנטיבות? ממה שראיתי יש סמפור סלים וכל מיני דברים שאינני מבין אותם כלל, וכאשר ניסיתי להעתיק קטעי קוד של הפתרונות הללו, נתקלתי בשגיאות משונות שלא הצלחתי להבין אותן בגלל שאינני מבין את הבסיס של סמפור סלים.
    מודה ומתוודה שכבר שנה אני דוחה את הנעילות הללו, עד שקרתה תאונה כצפוי, ואני אנה אני בא. אז מי שיכול לכוון כאן לנושא הזה מאיפה להתחיל יבורך מפי עליון אמן.

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

    OdedDvirO רפאלר 2 תגובות תגובה אחרונה
    1
    • OdedDvirO מנותק
      OdedDvirO מנותק
      OdedDvir
      השיב לארכיטקט ב נערך לאחרונה על ידי OdedDvir
      #2

      @ארכיטקט יש לך הסבר מאוד פשוט וברור כאן.

      תגובה 1 תגובה אחרונה
      4
      • רפאלר מנותק
        רפאלר מנותק
        רפאל
        השיב לארכיטקט ב נערך לאחרונה על ידי רפאל
        #3

        דוגמא פשוטה של שימוש בSemaphoreSlim

        var ss = new SemaphoreSlim(1, 1);
        
        await ss.WaitAsync();
        try
        {
        	await DoSomeThingAsync();
        }
        finally
        {
        	ss.Release();
        }
        

        הסבר בקצרה:

        • הבנאי מקבל שני פרמטרים:
          1. המספר ההתחלתי של בקשות לסמפור שיאושרו במקביל
          2. המספר המקסימלי של בקשות שיאושרו במקביל
            בדוגמא למעלה מכיוון שהמספר מוגדר לאחד - רק בקשה אחת תאושר בכל פעם.
        • המתודה WaitAsync ממתינה בצורה אסינכרונית עד אשר הCounter הפנימי של SemaphoreSlim יירד למספר נמוך יותר מהמספר המקסימלי שהוגדר, בסיום ההמתנה הCoutner הפנימי יעלה באחד ושורות הקוד הבאות יתבצעו.
        • המתודה Release מפחיתה את הCounter באחד, מה שמפנה מקום לבקשות הממתינות (חשוב לקרוא לRelease בתוך הFinally כך שהשחרור יתבצע גם במקרה של כשלון הקוד המופיע בTry).

        מספר הערות:

        • חשוב שהאוביקט SemaphoreSlim יהיה משותף כך שלא יווצר מופע חדש בכל קריאה למתודה או יצירת מופע שמכיל אותו כשדה (כדאי לחשוב בכיוון שלSingleton או שדה סטטי).
        • עבור EntityFramework השימוש בSemaphoreSlim אינו דרוש תודות לConcurrency Tokens/Timestamp שנוצרו על מנת לטפל בבעיה זו, להלן מדריך לOptimistic Concurrency.
        תגובה 1 תגובה אחרונה
        7
        • א מנותק
          א מנותק
          ארכיטקט
          כתב ב נערך לאחרונה על ידי
          #4

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

          תודה לכל המסייעים.

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

          תגובה 1 תגובה אחרונה
          0

          בא תתחבר לדף היומי!
          • התחברות

          • אין לך חשבון עדיין? הרשמה

          • התחברו או הירשמו כדי לחפש.
          • פוסט ראשון
            פוסט אחרון
          0
          • דף הבית
          • קטגוריות
          • פוסטים אחרונים
          • משתמשים
          • חיפוש
          • חוקי הפורום