Docstoc

SQL Transaction Processing

Document Sample
SQL Transaction Processing Powered By Docstoc
					      ‭‫ ‬תנועות‬SQL
‭‫ ‬בסביבת‬‭‫‬עיבוד‬
     Transaction
     Processing


                 1
          ‫‬תנועות‪- ‭‬‬
      ‫‬מטרה‪‭‬‬      ‫‬עיבוד‪‭‬‬
      ‫•‬              ‫‬בסיס‪‭‬‬   ‫ה‪‬‭‬אמינות‪‭‬‬
              ‫‬על‪‬ ‭‬ושלמות‪‬ ‭‬הנתונים‪‭‬‬
              ‫‬עתירת‪‬ ‭‬ומרובת‪‭‬‬
       ‫‬בסביבה‪‬ ‭‬תנועות‪‬ ‭‬משתמשים‪‭‬‬
       ‫‬את‪‬ ‭‬רצף‪RDBMS ‭‬‬
‫‬מערכת‪• ‭‬‬                      ‫‬צריכה‪‭‬‬
                 ‫‬להבטיח‪‬‭‬הצלחת‪‭‬‬
      ‫‬פקודות‪‬ ‭‬ולא‪‬‭‬את‪‬ ‭‬הפקודה‪‭‬‬
‫‬הבודדת‪‭‬‬    ‫‬העדכון‪‬ ‭‬רק‪‬‭‬הצלחת‪‭‬‬




                                   ‫2‬
            ‫‬לביצוע‪‭‬‬
       ‫‬תנועה‪‭‬‬    ‫‬דוגמא‪‭‬‬
       ‫012‬      ‫‬אירוע‪‬ :‭‬סטודנט‪‭‬‬
‫001-‪‬ M‬רישום‪‬ ‭‬שמספרו‪‬ ‭‬לקורס‪• ‭‬‬
                                ‫‬לסמסטר‪‭‬‬
                        ‫‬קיץ‪2007 ‭‬‬




                                    ‫3‬
                    ‭‫‬לביצוע‬
               ‭‫‬תנועה‬    ‭‫‬דוגמא‬
Grades                                         ‫ציונים‬
STUDENT_ID    COURSE_ID   SEMESTER   TERM   GRADE
 ‫מס. סטודנט‬    ‫מס. קורס‬    ‫סמסטר‬     ‫מועד‬    ‫ציון‬
    105          C-55      SUM2007    A      70
    210         M-100      AUT2008    A      90
    105         M-100      SUM2007    B      50
    105         C-200      AUT2008    A      85
    210         C-200      AUT2008    A      80
    210          B-10      WIN2008    A      50
    105          B-40      WIN2008    B      70
    245         M-100      AUT2008    A      80
    245          B-10      AUT2008    A      70
    200         C-200      AUT2008    B      50
    200          B-10      AUT2008    A      65
    245          B-40      WIN2007    A      95
    200         M-100      SUM2007    B      90
    310         M-100      SUM2007    A      100

                                                    4
               ‭‫‬לביצוע‬
          ‭‫‬תנועה‬    ‭‫‬דוגמא‬
                              •
                                       - ‭‫ונים‬
                                  (‭‫‬ריקה‬
      ‭‫ ‬בטבלת‬‭‫‬שנרשמו‬
‭‫ ‬קורסים‬‭‫‬לקורס‬             ‭‫* ‬מספר‬
                    ‭‫ ‬הסטודנטים‬‭‫‬עדכון‬
•                   INSERT INTO GRADES
(COURSE_ID,STUDENT_ID,SEMESTER,TERM)
    •    VALUES (‘M-100’,’210’,’SUM2007’,’A’)
                                    •       H




•                       UPDATE COURSES
        • SET CUR_ENROLL=CURR_ENROLL+1
        •        WHERE COURSE_ID=‘M-100’    J




                                            5
          ‫‬לביצוע‪‭‬‬
     ‫‬תנועה‪‭‬‬    ‫‬דוגמא‪‭‬‬
       ‫‬רצף‪‬ ‭‬הפקודות‪‬ ‭‬להתבצע‪‬ ‭‬הן‪‭‬‬
‫‬פקודה‪• ‭‬‬‫‬כאילו‪‭‬‬   ‫‬חייב‪‭‬‬    ‫‬של‪2 ‭‬‬
                                 ‫‬אחת‪‭‬‬
          ‫‬יהיה‪‬ ‭‬ולא‪‭‬‬      ‫‬בסיס‪‭‬‬
    ‫‬אחרת‪‬ ‭‬המתונים‪‬ ‭‬משובש‪‬ ‭‬אמין‪• ‭‬‬




                                  ‫6‬
             ‫‬דוגמא‪‭‬‬
         ‫‬נוספת‪‭‬‬
       ‫‬עדכון‪‬ ‭‬שורות‪‬ ‭‬כדי‪‬ ‭‬פקודה‪‭‬‬
‫‬מספר‪‬ ‭‬תוך‪‬ ‭‬ביצוע‪‬ ‭‬אחת‪• :‭‬‬
            ‫‬מתן‪‬ ‭‬לכל‪‭‬‬         ‫‬כל‪‭‬‬
   ‫‬עדכון‪‬‭‬הציונים‪‬) ‭‬בונוס‪‬ (‭‬הסטודנטים‪‭‬‬
           ‫‬שלמדו‪‭‬‬
     ‫‬קיץ‪‬ M-100 1998 ‭‬בקורס‪‭‬‬
   ‫7002‬                         ‫‬בסמסטר‪‭‬‬




                         ‫7002‪SUM‬‬

                                    ‫7‬
     ‫‬הגדרת‪‭‬‬
‫‬תנועה‪‭‬‬




               ‫8‬
              ‫‬של‪‭‬‬
         ‫‬תכונות‪‬ ‭‬תנועה‪‭‬‬
                ‫‬תנועה‪‬ ‭‬לקיים‪4 ‭‬‬
      ‫‬תכונות‪• ) ‭‬‬              ‫‪ACID‬‬
                       ‫( ‬כל‪‬ ‭‬חייבת‪‭‬‬
        ‫)‪(Atomicity‬‬
‫‬אטומיות‪*‭‬‬          ‫-‬
‫‬עקביות‪‭‬‬                    ‫‬את‪‭‬‬    ‫‬חייבת‪‭‬‬
      ‫‬תנועה‪‬ ‭‬להעביר‪‬‭‬בסיס‪* (Consistency) - ‭‬‬
    ‫‬הנתונים‪‬ ‭‬תקין‪‬ ‭‬למצב‪‬ ‭‬אחר‪‬ ‭‬שתוך‪‭‬‬
 ‫‬ממצב‪‬ ‭‬אחד‪‬ ‭‬תקין‪‬ ‭‬אפילו‪‬ ‭‬כדי‪‭‬‬
                                         ‫‬בסיס‪‭‬‬
                                  ‫קינות‪‬ ‭‬הנתונים‪‭‬‬
      ‫‬חייבות‪‬* (Independency) - ‭‬תלות‪‭‬‬
           ‫‬אי‪‭‬‬                         ‫‬תנועות‪‭‬‬
                                           ‫‬זו‪‭‬‬
                                        ‫‪‬ ‭‬מזו‪‭‬‬
                                             ‫תלוי‪‭‬‬
                                ‫‬שהתנועה‪‭‬‬
         ‫‬הסתימה‪* (Durability) - ‭‬‬
  ‫‬נצחיות‪‭‬‬                                ‫‬ברגע‪‭‬‬
           ‫‬חייבים‪‬ ‭‬בבסיס‪‭‬‬
  ‫‬העדכונים‪‬ ‭‬להירשם‪‬ ‭‬הנתונים‪‭‬‬        ‫‬בהצלחה‪‭‬‬

                                           ‫9‬
      ‫‬כפקודת‪COMMIT ‭‬‬
‫‬הפקודה‪‭‬‬
         ‫‪SQL‬‬
              ‫•‬                 ‫‪:‭‬‬
       ‫‬להודיע‪‭‬‬         ‫‬שהתנועה‪‭‬‬
 ‫‬הסתימה‪‬ * RDBMS ‭‬למערכת‪‭‬‬

     ‫*‬פקודות‪‬ ‭‬שהיו‪‬ ‭‬להתבצע‪‭‬‬
 ‫‬כחלק‪‭‬‬    ‫‬כל‪‬ ‭‬העדכון‪‬ ‭‬צריכות‪‭‬‬

                  ‫‬ומצב‪‬ ‭‬הנתונים‪- ‭‬‬
              ‫‬תקין‪‭‬‬       ‫‬בסיס‪‭‬‬


                               ‫01‬
              COMMIT - ‭‫‬דוגמא‬
        ‭‫‬הפקודה‬

    •                      INSERT INTO GRADES
•       (COURSE_ID,STUDENT_ID,SEMESTER,TERM)
         •       VALUES (‘M-100’,’210’,’SUM2007’,’A’)
                                           •        H




    •                          UPDATE COURSES
             • SET CUR_ENROLL=CURR_ENROLL+1
             •           WHERE COURSE_ID=‘M-100’    J




    •                                     COMMIT
                                                   11
         ‫‪ROLLBACK‬‬
   ‫‬הפקודה‪‭‬‬
            ‫‬גלילה‪‭‬‬
       ‫‬לאחור‪‭‬‬

         ‫‬היישום‪‬ ‭‬מבסיס‪‭‬‬
‫‬לתוכנית‪‬ ‭‬לבקש‪‬ ‭‬הנתונים‪• ‭‬‬   ‫‬מאפשרת‪‭‬‬
        ‫‬מתחילת‪‭‬‬
  ‫‬התנועה‪‭‬‬           ‫‬את‪‬‭‬העדכונים‪‭‬‬
               ‫‬שבוצעו‪‭‬‬      ‫‬לבטל‪‬‭‬כל‪‭‬‬




                                  ‫21‬
      ROLLBACK -
‭‫‬הפקודה‬

                   AUT2008



                   AUT2008



                   AUT2008




                             13
       ‫‬מודל‪‭‬‬
‫‪‬ - Transaction Model‬התנועות‪‭‬‬
             ‫‬לפי‪‭‬‬
         ‫‪‬ SQL‬תקן‪‭‬‬
         ‫‬את‪‬ RDBMS ‭‬את‪‬ ‭‬שבו‪‭‬‬
 ‫‬מגדיר‪‬‭‬האופן‪‬ ‭‬מערכת‪• ‭‬‬          ‫‬מזהה‪‭‬‬
         ‫‬את‪‭‬‬ ‫‬את‪‬ ‭‬המוצלח‪‭‬‬
    ‫‬או‪‬‭‬כשלון‪‭‬‬                   ‫‬תחילת‪‭‬‬
                    ‫‬התנועה‪‬,‭‬סיומה‪‭‬‬
                                  ‫‬ביצוע‪‭‬‬
                            ‫‬התנועה‪‭‬‬




                                    ‫41‬
                   ‫‬מודל‪‭‬‬
            ‫‬התנועות‪‭‬‬
    ‫‬בתוכנית‪‭‬‬
‫‬או‪• ‭‬‬            ‫‬תנועה‪‬ - ‭‬העדכון‪‭‬‬
           ‫‬פקודת‪‬ ‭‬הראשונה‪‭‬‬         ‫‬תחילת‪‭‬‬
         ‫‬לאחר‪‭‬‬      ‫‪‬ COMMIT‬העדכון‪‭‬‬
  ‫‬פקודת‪‬ ‭‬הראשונה‪‬ ‭‬הפקודה‪‭‬‬
                ‫‬סיום‪‬ ‭‬תקין‪‬ - ‭‬ביצוע‪‭‬‬
        ‫‬תנועה‪‬ ‭‬או‪ ‭‬ע”י ‬הפקודה‪• ‭‬‬
                        ‫‬אם‪‬ ‭‬היישום‪‭‬‬
       ‫‬או‪‬‭‬תוכנית‪‬ ‭‬מסתימת‪COMMIT ‭‬‬
              ‫‬תנועה‪‬‭‬תקין‪‬ - ‭‬ביצוע‪‭‬‬
     ‫‬סיום‪‬ ‭‬לא‪‬ ‭‬או‪ ‭‬ע”י ‬הפקודה‪• ‭‬‬
      ‫‬עפה‪ROLLBACK ‭‬‬          ‫‬או‪‬‭‬תוכנית‪‭‬‬
                      ‫‬אם‪‬ ‭‬היישום‪“ ‭‬‬   ‫”‬


                                       ‫51‬
           ‫‬של‪‭‬‬     ‫‬בדיקה‪‭‬‬
    ‫‬מושהית‪‬ ‭‬אילוצים‪‭‬‬
        ‫‪SQL‬‬       ‫‬מכילה‪‬ ‭‬המאפשרת‪‬ ‭‬האם‪‭‬‬
  ‫‬לקבוע‪‬ ‭‬בדיקת‪‬ ‭‬שפת‪• ‭‬‬          ‫‬פקודה‪‭‬‬
        ‫‬של‪‬ ‭‬לסטודנט‪(‭‬‬
   ‫‬תתבצע‪‭‬‬                      ‫‬אילוץ‪‬ ) ‭‬מספר‪‭‬‬
                ‫‬כגון‪‬ :‭‬מכסימלי‪‬ ‭‬בחינות‪‭‬‬
      ‫‬מיד‪‬ ‭‬כל‪‬ ‭‬עדכון‪‬ ‭‬טבלה‪‬ ) ‭‬מחדל‪(‭‬‬
    ‫‬לאחר‪‬‭‬פקודת‪‬ ‭‬של‪‬ ‭‬ברירת‪‬ ‭‬או‪‭‬‬
                ‫‬הבדיקה‪‬ ‭‬סיום‪‬ ‭‬של‪‭‬‬
          ‫‬לאחר‪‬ ‭‬מוצלח‪‬ ‭‬התנועה‪‭‬‬      ‫‬להשהות‪‭‬‬
        ‫‬לא‪‬ ‭‬את‪‬RDBMS ‭‬בדיקת‪‬ ‭‬תיכשל‪‭‬‬
‫‬אם‪‬ ‭‬האילוץ‪‬ ‭‬מערכת‪• ‭‬‬               ‫‬תבצע‪‭‬‬
                                ‫‬התנועה‪‬ ‭‬והיא‪‭‬‬
                          ‫‬כולה‪‬ ‭‬תבוטל‪‭‬‬



    ‫‪‬ CONSTRAINTS MAX_NUM_OF_EXAMS‬דוגמא‪• ‭‬‬
          ‫‪: SET‬‬
                                    ‫‪DEFFERED‬‬
                                           ‫61‬
         ‫‬יומן‪‭‬‬
  ‫)‪‬ (LOG FILE‬אירועים‪‭‬‬
         ‫‪‬ - ROLLBACK‬המאפשר‪‬ ‭‬את‪‭‬‬
‫‬להפעיל‪‬‭‬פקודת‪ ‭‬ה •‬ ‫‬המנגנון‪‭‬‬
                                  ‫‬יומן‪‭‬‬
                          ‫‬הינו‪‬ ‭‬האירועים‪‭‬‬




                                      ‫71‬
                    ‫‬יומן‪‭‬‬
             ‫‬אירועים‪‭‬‬
              ‫•‬                           ‫‬הנתונים‪‭‬‬
                                     ‫‬האלה‪:‭‬‬     ‫ת‪‭‬‬

                                            ‫‬בוצעה‪‭‬‬
                                      ‫‪‬ ‭‬התנועה‪‭‬‬
                                                ‫ה‪‭‬‬
                                          ‫‬התנועה‪‭‬‬

                    ‫עדכון‪‬ ,‭‬תחילת‪‬ ‭‬סוף‪‭‬‬
              ‫, ‬הוספת‪‬ ,‭‬תנועה‪‬ ,‭‬תנועה‪(‭‬‬
                                      ‫‬בוצעה‪‭‬‬
                                ‫‪‬ ‭‬הפעולה‪‭‬‬
      ‫‬תוכן‪‬ ‭‬לפני‪‭‬‬
‫)‪‬ * (Before Values‬השורה‪‬ ‭‬העדכון‪‭‬‬
            ‫‬תוכן‪‬ ‭‬לאחר‪‭‬‬
      ‫)‪‬ * (After Values‬השורה‪‬ ‭‬העדכון‪‭‬‬

                                             ‫81‬
       ‫‬שיחזור‪‭‬‬
‫‬לאחור‪- ‭‬‬           ‫‪Backward Recovery‬‬
              ‫‬תהליך‪‭‬‬

          ‫: ‪‬ ROLLBACK‬במקרה‪‬ ‭‬ביצוע‪‭‬‬
   ‫‬מופעל‪‬ ‭‬של‪‬ ‭‬פקודת‪• ‭‬‬
         ‫*‬             ‫‬יקרא‪‬ ‭‬כרונולוגי‪‭‬‬
                   ‫‬הפוך‪‭‬‬       ‫אירועים‪‬ ‭‬בסדר‪‭‬‬
      ‫*‬          ‫‪RDBMS‬‬
           ‫‬מערכת‪‭‬‬                   ‫חזיר‪‬‭‬בסיס‪‭‬‬
                              ‫‬את‪‬ ‭‬הנתונים‪‭‬‬
                        ‫‬שלפני‪‭‬‬
                  ‫‬למצבו‪‬ ‭‬העדכון‪‭‬‬




                                         ‫91‬
       ‫‪‬ Recovery Forward‬שיחזור‪‭‬‬
‫‬לפנים‪- ‭‬‬     ‫‬תהליך‪‭‬‬

    ‫•‬            ‫‬משמש‪‬ ‭‬שיחזור‪‭‬‬
           ‫‬האירועים‪‬ ‭‬גם‪ ‭‬ב- “ ‬לפנים‪”‭‬‬‫ן‪‭‬‬
                  ‫‬של‪‬ ‭‬הנתונים‪‬ ‭‬של‪‭‬‬
             ‫‬במקרה‪‬ ‭‬תקלה‪‭‬‬     ‫‬בסיס‪‭‬‬
        ‫‬להפעיל‪‬‭‬קובץ‪‬ ‭‬האחרון‪‬‭‬כל‪‭‬‬
‫‬ניתן‪‬ ‭‬על‪‬ ‭‬הגיבוי‪‬ ‭‬את‪‬‭‬השורות‪• ‭‬‬
                   ‫‬שאחרי‪‭‬‬
             ‫)‪‬ “” (After Image‬העדכון‪‭‬‬
                   ‫‬לפי‪‬ ‭‬כרונולוגי‪‬ ‭‬הם‪‭‬‬
              ‫‬שבו‪‬‭‬בוצעו‪‭‬‬       ‫‬סדר‪‭‬‬



                                    ‫02‬
                ‭‫ ‬יומן‬‭‫ ‬קטע‬‭‫‬דוגמא‬
         ‭‫ ‬אירועים‬‭‫ ‬מקובץ‬‭‫‬של‬

                                   User-                                          Before       After 
Tran-id   Date         Time            id   Terminal   Action   Table                 Values       Values

Grd-01    12/02/2008    07:30:35   Dan      Ter-05     Start                                              


Grd-01    12/02/2008    07:31:01   Dan      Ter-05     Update   Grades            …………         …………

Dpt-08    12/02/2008    07:31:28   Ron      Ter-08     Start                                              


Grd-01    12/02/2008    07:32:02   Dan      Ter-05     Insert   Grades                         …………

Dpt-08    12/02/2008    07:32:25   Ron      Ter-08     Delete   Departments       …………

Grd-01    12/02/2008    07:32:54   Dan      Ter-05     Commit                                             


Dpt-07    12/02/2008    07:33:10   Eyal     Ter-10     Start                                              

Dpt-08    12/02/2008    07:33:18   Ron      Ter-08     Commit                                             


Dpt-07    12/02/2008    07:33:34   Eyal     Ter-10     Insert   Departments                    …………

                                                                                                    21
       ‫‬דוגמא‪‬ ‭‬קטע‪‬ ‭‬יומן‪‭‬‬
‫‬של‪‬ ‭‬מקובץ‪‬ ‭‬אירועים‪‭‬‬

                 ‫‪Eyal‬‬     ‫‬הפעיל‪‭‬‬
       ‫70-‪‬ Dpt‬תנועה‪‬ ‭‬המשתמש‪• ‭‬‬
           ‫‬והספיק‪‬ ‭‬שורה‪‭‬‬
     ‫‬בשעה‪‬ 7:33:10 ‭‬להוסיף‪‬ ‭‬לטבלת‪‭‬‬
                                ‫‬מחלקות‪‭‬‬
        ‫‬להסתיים‪‬ ‭‬שלא‪‭‬‬
 ‫‬מכיוון‪‬ ‭‬נרשמה‪• ‭‬‬           ‫‬לא‪‭‬‬
                        ‫‬התנועה‪‬‭‬הספיקה‪‭‬‬
                   ‫‬האירועים‪Commit ‭‬‬
              ‫‬רשומת‪‭‬‬             ‫‬ביומן‪‭‬‬
          ‫‬כדי‪‭‬‬           ‫‬נצטרך‪‬ ‭‬את‪‭‬‬
   ‫‬לבטל‪‬‭‬השורה‪‬ Rollback ‭‬לבצע‪• ‭‬‬
          ‫‬שהמפתח‪‬ ‭‬רשום‪‭‬‬
     ‫‬שלה‪‬ ‭‬ביומן‪‭‬‬             ‫‬מטבלת‪“ ‭‬‬
                         ‫‬מחלקות‪”‭‬‬
     ‫‬כחלק‪“After ‭‬‬     ‫”‪“Before Values‬‬
      ‫‬האירועים‪‬ ‭‬מעמודת‪‭‬‬
                                    ‫22‬
          ‫‬רישום‪‭‬‬     ‫”‬
      ‫‬פרוטוקול‪‬ “ ‭‬מראש‪‭‬‬
          ‫‪Write‬‬
‫‬ברוב‪‬ Ahead Log Protocol ‭‬פרוטוקול‪• ‭‬‬‫‬קיים‪‭‬‬
                                ‫‪- RDBMS‬‬
                         ‫‬מערכות‪ ‭‬ה‬
         ‫‬זה‪‭‬‬
 ‫‬מערכת‪• ‭‬‬         ‫‬לפי‪‭‬‬
           ‫‬תחילה‪‬ RDBMS ‭‬פרוטוקול‪‭‬‬‫‬מעדכנת‪‭‬‬
          ‫‬ורק‪‬ ‭‬מכן‪‬‭‬בסיס‪‭‬‬         ‫‬יומן‪‭‬‬
   ‫‬את‪‬ ‭‬האירועים‪‬ ‭‬לאחר‪‬ ‭‬את‪‬ ‭‬הנתונים‪‭‬‬




                                       ‫32‬
               ‫‬בו‪-‭‬‬
            ‫‬עדכון‪‬‭‬זמני‪‭‬‬
      ‫‪Concurrent Updates‬‬
        ‫‬יותר‪‬ ‭‬לעדכן‪‭‬‬‫‬מצב‪‬ ‭‬משתמשים‪‭‬‬
  ‫‬או‪‬ ‭‬מנסים‪‬ ‭‬בסיס‪• ‭‬‬        ‫‬שבו‪2 ‭‬‬
                          ‫‬נתונים‪‬ ‭‬באותו‪‭‬‬
                      ‫‬אחד‪‬ ‭‬זמן‪‭‬‬
          ‫‬מרובת‪‭‬‬
‫)‪‬ User Environment‬בסביבה‪‬ ‭‬משתמשים‪• ‭‬‬
                   ‫‪(Multi‬‬
        ‫‬משתמש‪‬ ‭‬עותק‪‬ ‭‬של‪‬ ‭‬היישום‪‭‬‬
 ‫‬מקבל‪‬ ‭‬משלו‪‬ ‭‬תוכנית‪‬ ‭‬בזיכרון‪‭‬‬ ‫‬כל‪‭‬‬
                ‫•‬                         ‫‪‭‬‬
                                    ‫‬זיכרון‪:‭‬‬

         ‫‬המשתנים‪‭‬‬
 ‫‬והנתונים‪‭‬‬           ‫* ‬שטח‪‬ ‭‬שבו‪‭‬‬
                ‫‬עבור‪‬ ‭‬עבודה‪‬ ‭‬נרשמים‪‭‬‬
                               ‫‬המעובדים‪‭‬‬

                                     ‫42‬
      ‫‬כניסות‪- Reentrant ‭‬‬
‫‬שיטת‪ ‭‬ה‬               ‫‬רב‪-‭‬‬
        ‫‬רק‪‬ ‭‬אחד‪‬ ‭‬תוכנית‪‭‬‬
‫‬אחרת‪‬- ‭‬עותק‪‬ ‭‬של‪‬ ‭‬היישום‪• ‭‬‬ ‫‬אפשרות‪‭‬‬
          ‫‬יחד‪‬‭‬מראה‪‬ ‭‬נפרד‪‬ ‭‬כל‪‭‬‬
  ‫‬נשמר‪‬ ‭‬עם‪‬ ‭‬מקום‪‬ ‭‬עבור‪‬‭‬משתמש‪‭‬‬
                 ‫‬מקבל‪‬ ‭‬עבודה‪‭‬‬
         ‫‬משתמש‪‬ ‭‬שטחי‪‬ ‭‬נפרדים‪• ‭‬‬ ‫‬כל‪‭‬‬




                                   ‫52‬
          ‫‪Multitasking‬‬
        ‫‬שיטת‪‬ ‭‬של‪‬ ‭‬הפעלה‪‬ ‭‬מספר‪‭‬‬
‫‬עבודה‪‬ ‭‬מערכת‪‬ ‭‬לפיה‪‬ ‭‬משימות‪• ‭‬‬
                    ‫‬במקביל‪‬‭‬אותו‪‭‬‬
                ‫‬על‪‬ ‭‬מעבד‪‭‬‬     ‫‬מתבצעות‪‭‬‬
        ‫‬המערכת‪‬ ‭‬את‪‬ ‭‬לכל‪‬ ‭‬לפרק‪‭‬‬
   ‫‬מקצה‪‬‭‬המעבד‪‬ ‭‬משימה‪‬ ‭‬זמן‪• ‭‬‬
          ‫‬ומקצה‪‭‬‬    ‫‬מפסיקה‪‬‭‬ביצוע‪‭‬‬
    ‫‬את‪‬ ‭‬המשימה‪‬ ‭‬המעבד‪‭‬‬         ‫‬מסוים‪,‭‬‬
                                 ‫‬למשימה‪‭‬‬
                            ‫‬אחרת‪‭‬‬
         ‫‬על‪‭‬‬     ‫‬זה‪‬ ‭‬בעזרת‪‬ ‭‬מקום‪‭‬‬
 ‫‬מתבצע‪‬ ‭‬מראה‪‬ ‭‬המצביע‪‬‭‬הפקודה‪• ‭‬‬
                       ‫‬בכל‪‭‬‬    ‫‬האחרונה‪‭‬‬
                  ‫‬שבוצעה‪‬ ‭‬משימה‪‭‬‬

                                     ‫62‬
      ‫‬בניהול‪‭‬‬
‫‬גישות‪‬ ‭‬תנועות‪‭‬‬
             ‫‬גישת‪‭‬‬
  ‫(‪‬ Oracle‬הנעילות‪• ) ‭‬‬
                    ‫‬גישת‪‭‬‬
          ‫‬הגירסאות‪• ‭‬‬



                     ‫72‬
                        ‫‬העדכון‪‭‬‬
                  ‫ת‪‬ “ ‭‬האבוד‪"‭‬‬
         ‫)‪(Lost Update‬‬
                     ‫‬כתוצאה‪‬ ‭‬בו‪-‭‬‬
                ‫‬מעדכון‪‬‭‬זמני‪• ‭‬‬    ‫‬נגרמת‪‭‬‬
       ‫‬סטודנטים‪‬ ‭‬להירשם‪‬ ‭‬זמן‪‭‬‬
‫‬באותו‪‬ ‭‬לאותו‪• ‭‬‬    ‫‬מנסים‪‭‬‬     ‫‬דוגמא‪2 :‭‬‬
                                     ‫‬קורס‪‭‬‬
     ‫‬שמכילה‪‭‬‬
‫‬בין‪• ‭‬‬           ‫‬נתבונן‪‬ ‭‬שקורה‪‬‭‬טבלת‪“ ‭‬‬
           ‫‬במה‪‬ ‭‬עם‪‬ ‭‬קורסים‪”‭‬‬

                            ‫‬מכסימלי‪‭‬‬
                      ‫‬לקורס‪”‭‬‬     ‫ודנטים‪‭‬‬
              ‫”* “ ‬סטודנטים‪‬ ‭‬נרשמו‪‭‬‬
         ‫‬שכבר‪‬ ‭‬לקורס‪‭‬‬       ‫‬מספר‪‭‬‬


                                      ‫82‬
                          ‫העדכון‪‭‬‬
                    ‫“ ‬האבוד‪"‭‬‬
           ‫)‪(Lost Update‬‬
                     ‫‬נרשם‪‭‬‬      ‫002-‪C‬‬
              ‫‬סטודנט‪ ‭‬א’ ‬לקורס‪• ‭‬‬
         ‫‪‬ Select‬היישום‪‭‬‬
 ‫‬את‪‬ ‭‬קורס‪‬ ‭‬תוכנית‪‬ ‭‬מבצעת‪• ‭‬‬‫‬ושולפת‪‬‭‬שורת‪‭‬‬
‫‬לסטודנט‪ ‭‬א 002-‪C‬‬    ‫‬אל‪‬ ‭‬העבודה‪‭‬‬
               ‫‬שהוקצה‪‭‬‬                ‫‬מבסיס‪‭‬‬
                           ‫’ ‬הנתונים‪‬‭‬שטח‪‭‬‬




                                         ‫92‬
                ‫‬העדכון‪‭‬‬
          ‫‪‬ “ ‭‬האבוד‪"‭‬‬
                ‫העדכון‪‭‬‬
 ‫)‪(Lost Update‬‬
      ‫‬לאותו‪‭‬‬  ‫‬מבקש‪‭‬‬
‫‬סטודנט‪ ‭‬ב’ ‬להירשם‪‬ ‭‬קורס‪• ‭‬‬




                         ‫03‬
               ‫‬העדכון‪‭‬‬
         ‫‪‬ “ ‭‬האבוד‪"‭‬‬
‫)‪(Lost Update‬‬
               ‫א’ ‬את‪‭‬‬
       ‫‬סטודנט‪‬‭‬מאשר‪‬‭‬ההרשמה‪• ‭‬‬
                 ‫•‬
                                   ‫‪‭‬‬
                             ‫נרשמו‪”‭‬‬
                                  ‫‪‭‬‬
                       ‫‪* Commit‬‬
                  ‫‬מבצעת‪‭‬‬
          ‫‬של‪‭‬‬     ‫‬משחררת‪‬‭‬שטח‪‭‬‬
‫‬את‪‬ ‭‬העבודה‪‬ ‭‬סטודנט‪ ‭‬א *‬    ‫’‬




                             ‫13‬
               ‫‬העדכון‪‭‬‬
         ‫‪‬ “ ‭‬האבוד‪"‭‬‬
‫)‪(Lost Update‬‬
        ‫‬סטודנט‪ ‭‬ב’ ‬אף‪‬ ‭‬את‪‭‬‬
‫‬מאשר‪‬‭‬הוא‪‬‭‬ההרשמה‪• ‭‬‬




                         ‫23‬
                      ‫‬העדכון‪‭‬‬
                ‫‪‬ “ ‭‬האבוד‪"‭‬‬
       ‫)‪(Lost Update‬‬
         ‫‬קרא‪‬‭‬אותם‪‭‬‬      ‫‬כל‪‭‬‬
 ‫‬הבעיה‪‬- ‭‬משתמש‪‬ ‭‬את‪‬ ‭‬נתונים‪• ‭‬‬
    ‫‬שבזיכרון‪‭‬‬
‫‬מבלי‪‭‬‬            ‫‬לשטחי‪‭‬‬    ‫‬מבסיס‪‭‬‬
            ‫‬הנתונים‪‬ ‭‬העבודה‪‭‬‬
        ‫‬עומדים‪‭‬‬
 ‫‬שהנתונים‪‬ ‭‬להתעדכן‪‭‬‬       ‫‬להתייחס‪‭‬‬
                      ‫‬לעובדה‪‭‬‬
                   ‫‬בינתיים‪‬ ‭‬משתמש‪‭‬‬
               ‫‬אחר‪‭‬‬     ‫ע”י‬




                                ‫33‬
      ‫‬עדכון‪‬ ‭‬שנמצאת‪‭‬‬
‫‬בתהליך‪‭‬‬    ‫‬בעיית‪‬ ‭‬רשומה‪‭‬‬
      ‫)‪(Uncommitted Update‬‬
 ‫‬עדכון‪‭‬‬
      ‫‬הבעיה‪‬ ‭‬כאשר‪‬ ‭‬יישום‪‭‬‬
 ‫‬נוצרת‪‬ ‭‬תוכנית‪‬ ‭‬אחת‪• ‭‬‬
      ‫‬עדכון‪‭‬‬    ‫‬נמצאת‪‭‬‬
  ‫‬תוכנית‪ ‭‬ב’( ‬בתהליך‪‬ ‭‬שורה‪‭‬‬‫)‬
         ‫‬תוכנית‪‭‬‬   ‫‬קודם‪‭‬‬
    ‫‬שעודכנה‪‬ ‭‬לכן‪ ‭‬ע”י ‬יישום‪‭‬‬
         ‫א’( ‬לא‪‭‬‬        ‫‬אחרת‪) ‭‬‬
    ‫‬תוכנית‪‬ ‭‬שעדיין‪‬‭‬ביצעה‪‭‬‬
           ‫‬יבוצע‪‬ ‭‬לאחור‪‭‬‬
 ‫‬ואח‪”‭‬כ ‬גלילה‪‬ ‭‬של‪Commit ‭‬‬
                              ‫’‬
                       ‫‬תוכנית‪ ‭‬א‬

                             ‫43‬
      ‫‬עדכון‪‬ ‭‬שנמצאת‪‭‬‬
‫‬בתהליך‪‭‬‬    ‫‬בעיית‪‬ ‭‬רשומה‪‭‬‬
             ‫‬עדכון‪- ‭‬‬
        ‫‬דוגמא‪‭‬‬
           ‫•‬                      ‫‬יישום‪‭‬‬
                            ‫ת‪‬ ‭‬שונות‪:‭‬‬
          ‫‬של‪‭‬‬       ‫‬אחת‪‬ - ‭‬המספר‪‭‬‬
  ‫* ‬לעדכון‪‬ ‭‬המכסימלי‪‬ ‭‬סטודנטים‪‭‬‬

                       ‫‬רישום‪‭‬‬
                  ‫‬השניה‪‬ - ‭‬לקורס‪‭‬‬
                                 ‫*‬




                                   ‫53‬
      ‫‬עדכון‪‬ ‭‬שנמצאת‪‭‬‬
‫‬בתהליך‪‭‬‬    ‫‬בעיית‪‬ ‭‬רשומה‪‭‬‬
             ‫‬עדכון‪- ‭‬‬
        ‫‬דוגמא‪‭‬‬




                       ‫63‬
       ‫‬בתהליך‪‭‬‬
‫‬עדכון‪- ‭‬‬           ‫‬בעיית‪‬ ‭‬רשומה‪‭‬‬
             ‫‬עדכון‪‬ ‭‬שנמצאת‪‭‬‬
               ‫‬דוגמא‪‭‬‬




                               ‫73‬
       ‫‬בתהליך‪‭‬‬
‫‬עדכון‪- ‭‬‬           ‫‬בעיית‪‬ ‭‬רשומה‪‭‬‬
             ‫‬עדכון‪‬ ‭‬שנמצאת‪‭‬‬
               ‫‬דוגמא‪‭‬‬




                               ‫83‬
           ‫‬ניתוח‪‬ ‭‬לא‪‭‬‬
       ‫‬בעיית‪‬ ‭‬נתונים‪‬‭‬עקבי‪‭‬‬
        ‫‪Inconsistent Analysis‬‬
         ‫‬תוכנית‪ ‭‬א’ ‬דו‪”‭‬ח ‬את‪‬ ‭‬הסטודנטים‪‭‬‬
‫‬שנרשמו‪• ‭‬‬         ‫‬מפיקה‪‬ ‭‬המציג‪‬‭‬מספר‪‭‬‬
                                          ‫‬לפי‪‭‬‬
                                    ‫‬בפועל‪‬ ‭‬קורס‪‭‬‬
            ‫‬מתחילה‪‬ ‭‬ולשלוף‪‬ ‭‬מבסיס‪‭‬‬
   ‫‬לעבוד‪‬ ‭‬נתונים‪‬ ‭‬הנתונים‪• ‭‬‬              ‫‬תוכנית‪‭‬‬
                                           ‫‬זו‪‭‬‬
                ‫‬מתחילה‪‬ ‭‬תוכנית‪ ‭‬ב’‬
       ‫‬לרישום‪• ‭‬‬        ‫‬לפעול‪‭‬‬            ‫‬כדי‪‭‬‬
                                    ‫‬תוך‪‬ ‭‬העבודה‪‭‬‬
          ‫‬סטודנטים‪‬ ‭‬ומעדכנת‪‬‭‬נתוני‪‬ ‭‬הקורסים‪‭‬‬
     ‫‬שכבר‪‭‬‬       ‫‬את‪‬ ‭‬אחד‪‭‬‬        ‫‬לקורס‪‭‬‬
                                         ‫ע”י‬     ‫’‬
                                 ‫‬נקראו‪‬ ‭‬תוכנית‪ ‭‬א‬
          ‫‬מסיימת‪‬ ‭‬היא‪‬ ‭‬נתונים‪‭‬‬
  ‫‬תוכנית‪ ‭‬א’ ‬לעבוד‪‬ ‭‬מציגה‪‬ ‭‬שכבר‪• ‭‬‬       ‫‬כאשר‪‭‬‬
         ‫‬נכונים‪‬ ‭‬ותוך‪‬ ‭‬פעולתה‪‬ ‭‬הנתונים‪‭‬‬
   ‫‬התעדכן‪‭‬‬      ‫‬בסיס‪‭‬‬     ‫‬אינם‪‬ ‭‬מאחר‪‬ ‭‬כדי‪‭‬‬


                                                ‫93‬
             ‫‬מנגנון‪‭‬‬
      ‫)‪‬ (Locking‬הנעילות‪‭‬‬
                             ‫‬הגדרת‪‭‬‬
                      ‫- )‪‬ (Lock‬נעילה‪• ‭‬‬
           ‫‬בבסיס‪‭‬‬     ‫‬המבצעת‪‬ ‭‬של‪‭‬‬
    ‫‬סימון‪‬ ‭‬אובייקט‪‬ ‭‬הנתונים‪‭‬‬       ‫‬פעולה‪‭‬‬
      ‫‬על‪‬‭‬שהאובייקט‪‭‬‬
  ‫‬נמצא‪‭‬‬                   ‫‬כדי‪‭‬‬     ‫‬שורה‪,‭‬‬
               ‫) ‬טבלה‪‬ (..‭‬להצביע‪‬‭‬כך‪‭‬‬
             ‫‬של‪‬ ‭‬ולכן‪‬ ‭‬חסום‪‭‬‬
   ‫‬בתהליך‪‬ ‭‬עדכון‪‬ ‭‬הוא‪‬ ‭‬לגישה‪ ‭‬ע”י‬  ‫‬כרגע‪‭‬‬
                                  ‫‬משתמשים‪‭‬‬
                             ‫‬נוספים‪‭‬‬
      ‫‬כאשר‪‬ ‭‬מבקשת‪‬ ‭‬אובייקט‪‬ ‭‬היא‪‭‬‬
‫‬נעול‪‬ ‭‬תכנס‪• ‭‬‬     ‫‬לנעול‪‭‬‬     ‫‬תוכנית‪‭‬‬
          ‫‬עד‪‭‬‬
      ‫‬זה‪‬‭‬אשר‪‭‬‬        ‫‬הממתינות‪‭‬‬
               ‫‬לאובייקט‪‭‬‬              ‫‬לתור‪‭‬‬
                               ‫‬התוכניות‪‭‬‬
                  ‫‬את‪‭‬‬     ‫‬לה‪‭‬‬
            ‫‬הקודמת‪‬‭‬תשחרר‪‬‭‬הנעילה‪‭‬‬ ‫‬התוכנית‪‭‬‬
                                        ‫04‬
      ‫‬רמת‪‭‬‬
‫)‪‬ (Locking Granularity‬הנעילה‪‭‬‬

          ‫‬בסיס‪‭‬‬
  ‫‬תחום‪‬ ‭‬הנתונים‪•‭‬‬
       ‫‬להוראת‪‭‬‬
 ‫‬הנעילה‪‭‬‬    ‫‬שכפוף‪‭‬‬

                             ‫14‬
               ‫‬הנעילה‪‭‬‬
       ‫‬רמות‪‬ ‭‬האפשריות‪‭‬‬
       ‫- )‪‬ (Column Level Locking‬בתוך‪‭‬‬
‫‬עמודה‪‬ ‭‬שורה‪• ‭‬‬
       ‫‬לעדכן‪‭‬‬     ‫‬אחרות‪‭‬‬       ‫‬גישה‪‭‬‬
   ‫‬מונעת‪‬ ‭‬מתוכניות‪‬ ‭‬המבקשות‪‬ ‭‬אותה‪‭‬‬
                                ‫‬באותו‪‭‬‬
                           ‫‬עמודה‪‬ ‭‬שורה‪‭‬‬
      ‫‬אחרות‪‬ ‭‬שורה‪‭‬‬       ‫‬מונעת‪‬ ‭‬של‪‭‬‬
 ‫‬לא‪‬ ‭‬גישה‪‬ ‭‬תוכניות‪‬ ‭‬לאותה‪‬ ‭‬כדי‪• ‭‬‬
                               ‫‬עמודות‪‭‬‬
                          ‫‬לעדכן‪‬ ‭‬אחרות‪‭‬‬
             ‫‬רוב‪‭‬‬        ‫‬בגלל‪‭‬‬
     ‫‬אינן‪‬ RDBMS ‭‬המורכבות‪‬ - ‭‬מערכות‪• ‭‬‬
                         ‫‬תומכות‪‬ ‭‬ברמה‪‭‬‬
                       ‫‬בנעילה‪‬ ‭‬זו‪‭‬‬

                                     ‫24‬
            ‫‬הנעילה‪‭‬‬
    ‫‬רמות‪‬ ‭‬האפשריות‪‭‬‬
                  ‫‪(Row‬‬
            ‫- )‪‬ Level Locking‬שורה‪• ‭‬‬
           ‫‬תבצע‪‬ ‭‬של‪‬‭‬השורה‪RDBMS ‭‬‬
   ‫‬מערכת‪* ‭‬‬            ‫‬נעילה‪‬ ‭‬כל‪‭‬‬
                       ‫‬אילו‪‬ ‭‬בשורה‪‭‬‬
               ‫יחס‪‬ ‭‬עמודות‪‬ ‭‬מתעדכנות‪‭‬‬
  ‫‬תומכות‪‬ ‭‬נעילה‪‭‬‬
‫‬המסחריות‪‬ ‭‬בשיטת‪‬ ‭‬זו‪‭‬‬           ‫‬רוב‪‭‬‬
                          ‫* ‬המערכות‪‭‬‬
     ‫‪(Page‬‬                  ‫‬קלט‪/‭‬‬
‫‬פעולות‪‬ ‭‬פלט‪‬ Level Locking) - ‭‬דף‪• ‭‬‬
      ‫‬מתבצעות‪‬ ‭‬ברמה‪‬ ‭‬דף‪‭‬‬
  ‫‬תמיד‪‬ ‭‬של‪‬‭‬פיסי‪‭‬‬        ‫‬שיכול‪(Page) ‭‬‬
                       ‫‬או‪‭‬‬
                         ‫‬להכיל‪‬ ‭‬אחת‪‭‬‬
                   ‫‬שורה‪‬ ‭‬יותר‪‭‬‬

                                   ‫34‬
           ‫‬הנעילה‪‭‬‬
   ‫‬רמות‪‬ ‭‬האפשריות‪‭‬‬
              ‫- )‪(Table Level Locking‬‬
        ‫‬טבלה‪• ‭‬‬
        ‫‬תבצע‪‬ ‭‬של‪‬‭‬הטבלה‪RDBMS ‭‬‬
 ‫‬מערכת‪* ‭‬‬            ‫‬נעילה‪‬ ‭‬כל‪‭‬‬
      ‫‬להתייחס‪‬ ‭‬שורות‪‬ ‭‬עמודות‪‭‬‬
 ‫‬אילו‪‬ ‭‬ואילו‪‬ ‭‬בטבלה‪‭‬‬          ‫‬מבלי‪‭‬‬

        ‫* ‬למימוש‪‬ ‭‬מקטינה‪‬‭‬כמות‪‭‬‬
  ‫‬אולם‪‬ ‭‬את‪‬ ‭‬העבודה‪‭‬‬       ‫‬קלה‪‭‬‬

             ‫‬מרובת‪-‭‬‬
      ‫‬לסביבה‪‬ ‭‬משתמשים‪‭‬‬        ‫‬אינה‪‭‬‬
                         ‫* ‬מתאימה‪‭‬‬
         ‫‬בסיס‪‭‬‬
‫)‪‬ (Data Base Level Locking‬הנתונים‪• ‭‬‬
                    ‫*‬
                       ‫‬במצבים‪‭‬‬
                 ‫‬נדירים‪‭‬‬    ‫‬מיושמת‪‭‬‬
                                   ‫*‬
                                   ‫44‬
              ‫‬סוגי‪‭‬‬
       ‫)‪‬ (Lock Type‬הנעילות‪‭‬‬
        ‫‬נעילה‪‭‬‬
‫- )‪‬ (Exclusive Lock‬בלבדית‪• ‭‬‬         ‫‬אף‪‭‬‬
        ‫‬לעדכן‪‭‬‬‫‬לקרוא‪‭‬‬ ‫‬יישום‪‬ ‭‬אינה‪‭‬‬
      ‫‬תוכנית‪‬ ‭‬אחרת‪‬ ‭‬מורשית‪‬ ‭‬או‪‬ ‭‬את‪‭‬‬
                                 ‫‬הנתונים‪‭‬‬
                        ‫‬נעילה‪‭‬‬
               ‫- )‪‬ (Shared Lock‬שיתופית‪• ‭‬‬
        ‫‬תוכנית‪‬ ‭‬המבקשת‪‬ ‭‬שורה‪‬ ‭‬מחזיקה‪‭‬‬
  ‫‬אותה‪* ‭‬‬    ‫‬לקרוא‪‬ ‭‬מסוימת‪‭‬‬ ‫‬יישום‪‭‬‬
       ‫‬ובכך‪‬ ‭‬לתוכניות‪‭‬‬
  ‫‬אחרות‪‭‬‬                      ‫‬בסטטוס‪‬ ‭‬נעילה‪‭‬‬
               ‫‬של‪‬ “ ‭‬שיתופית‪‬ ”‭‬מתירה‪‭‬‬

          ‫‬מבקשת‪‬ ‭‬את‪‬ ‭‬היא‪‭‬‬
     ‫‬לעדכן‪‬‭‬השורה‪‬ ‭‬צריכה‪‭‬‬            ‫‬ברגע‪‭‬‬
                               ‫* ‬שהתוכנית‪‭‬‬
               ‫ל- “‬       ‫מ- “‬      ‫” ‬את‪‭‬‬
          ‫‬להעביר‪‬‭‬הנעילה‪‬ ‭‬שיתופית‪‬ ”‭‬בלבדית‪‭‬‬

                                          ‫54‬
      ‫‬לקבלת‪‭‬‬  ‫‬טבלת‪‭‬‬
‫‬החלטות‪‬ ‭‬נעילות‪‭‬‬




                        ‫64‬
       ‫‪Consistent read‬‬
               ‫‬נוצר‪‬ ‭‬של‪" ‭‬‬
     ‫‬אם‪‬ ‭‬מצב‪‬ ‭‬הרעבה‪• ) "‭‬‬ ‫(‪Starvation‬‬
          ‫‬הרעבה‪‬ – "‭‬מבקש‪‬ ‭‬קריאה‪‭‬‬
   ‫‬יישום‪‬ ‭‬לבצע‪‬ ‭‬בלבד‪• ‭‬‬             ‫"‬
                   ‫‬נעולה‪‬ ‭‬זמן‪‭‬‬
                 ‫‬לרשומה‪‬ ‭‬למשך‪‬ ‭‬רב‪‭‬‬
                        ‫‪Consistent Read‬‬
               ‫‬פיתרון‪• – ‭‬‬
         ‫‬לפני‪‭‬‬    ‫‬של‪‬ ‭‬מגירסה‪‭‬‬
‫‬קודמת‪‬ ) ‭‬העדכון‪• (‭‬‬    ‫‬קריאה‪‬ ‭‬רשומה‪‭‬‬
                              ‫‬ניהול‪‭‬‬
                     ‫‬מצריך‪‬ ‭‬גירסאות‪• ‭‬‬

                                   ‫74‬
          ‫‬לקבלת‪‭‬‬  ‫‬טבלת‪‭‬‬
    ‫‬החלטות‪‬ ‭‬נעילות‪‭‬‬




     ‫‬נעילת‪‭‬‬
‫‬בצע‪‬ ‭‬כתיבה‪‭‬‬
                ‫‬מגירסה‪‭‬‬
           ‫‬קודמת‪‭‬‬    ‫‬קרא‪‭‬‬




                              ‫84‬
         ‫)‪‬ (Deadlock‬ללא‪‭‬‬
     ‫‬נעילה‪‬ ‭‬מוצא‪‭‬‬
                         ‫‬נצחי‪‬ ‭‬המתנה‪‭‬‬
                  ‫‬מצב‪‬ ‭‬של‪‬ ‭‬לשורה‪• ‭‬‬
         ‫‬מצב‪‬ ‭‬תוכניות‪‬ ‭‬או‪‬ ‭‬נועלות‪‭‬‬
                    ‫)‬
‫‬יישום‪‬ ‭‬יותר‪‬ (‭‬אובייקט‪• ‭‬‬    ‫‬שבו‪2 ‭‬‬
               ‫‬להשתמש‪‭‬‬
             ‫‬בו‪‭‬‬          ‫‬השניה‪‭‬‬
                      ‫‬שהתוכנית‪‬ ‭‬מבקשת‪‭‬‬




                                    ‫94‬
            ‫‬נעילה‪‬ ‭‬מוצא‪- ‭‬‬
       ‫‬ללא‪‬ ‭‬דוגמא‪‭‬‬
        ‫‬תוכניות‪‬ ‭‬המעדכנות‪‬ 2 ‭‬שונות‪‭‬‬
‫‬שורות‪‬ ‭‬אולם‪• 2 ‭‬‬        ‫‬יישום‪‭‬‬

        ‫‬ומבצעת‪‬ ‭‬תוכנית‪‬‭‬מתחילה‪‬ ‭‬ושולפת‪‭‬‬
    ‫‬שורה‪‭‬‬    ‫‬לפעול‪‭‬‬  ‫א’‬      ‫‪*A‬‬


      ‫‬מתחילה‪‬ ‭‬ושולפת‪‭‬‬
  ‫‬שורה‪‭‬‬    ‫‬לפעול‪‭‬‬           ‫‪*B‬‬   ‫‬ומבצעת‪‭‬‬
                     ‫‬לה‪‬ ‭‬תוכנית‪ ‭‬ב’‬

    ‫‬לה‪‬ ‭‬בלבדית‪‬ ‭‬תוכנית‪‬‭‬מבקשת‪‬ ‭‬את‪‭‬‬
‫‬לקרא‪‬‭‬שורה‪‭‬‬   ‫א’‬       ‫‪*B‬‬       ‫‬ולבצע‪‬‭‬נעילה‪‭‬‬
                                              ‫נה‪‭‬‬
    ‫‬מבקשת‪‬ ‭‬את‪‭‬‬
‫‬לקרא‪‬‭‬שורה‪‭‬‬            ‫‪*A‬‬
               ‫‬תוכנית‪ ‭‬ב’‬           ‫ולבצע‪‬‭‬נעילה‪‭‬‬
                               ‫‬לה‪‬ ‭‬בלבדית‪‭‬‬
         ‫‬כבר‪‬ ‭‬התוכנית‪‬ ‭‬למצב‪‭‬‬
    ‫‬מוכנסת‪‬ ‭‬המתנה‪‭‬‬               ‫‬ששורה‪‭‬‬
                         ‫‬מכיוון‪‬ ‭‬זו‪‬ ‭‬נעולה‪‭‬‬

                                           ‫05‬
    ‫‬היחלצות‪‬ ‭‬של‪‬ ‭‬ללא‪‭‬‬
‫‬ממצב‪‬ ‭‬נעילה‪‬ ‭‬מוצא‪‭‬‬
         ‫•‬                     ‫לפני‪‭‬‬
                       ‫‪‬ ‭‬עדכון‪- ‭‬‬
       ‫‬כל‪‬ ‭‬צריכה‪‬ ‭‬מראש‪‬‭‬כל‪‭‬‬
 ‫*‬תוכנית‪‬ ‭‬להכריז‪‬ ‭‬על‪‬‭‬השורות‪‭‬‬

      ‫‪* RDBMS‬‬
 ‫‬מערכת‪‭‬‬                     ‫ילה‪‬ ‭‬את‪‭‬‬
                      ‫‬לבצע‪‬‭‬הנעילות‪‭‬‬
   ‫‬את‪‭‬‬      ‫‬אם‪‬ ‭‬מסוימת‪‬ ‭‬נעולה‪‭‬‬
 ‫*‬שורה‪‬ ‭‬כבר‪‬ ‭‬משחררים‪‬‭‬כל‪‭‬‬
                 ‫‬מתחיל‪‭‬‬      ‫‪‬ ‭‬ננעלו‪‭‬‬
             ‫שכבר‪‬ ‭‬והתהליך‪‬ ‭‬מחדש‪‭‬‬
       ‫‬קשה‪‬ ‭‬כי‪‬ ‭‬תוכנית‪‬ ‭‬אינה‪‭‬‬
   ‫‬בד‪”‭‬כ ‬יישום‪‬ ‭‬יודעת‪‭‬‬   ‫* ‬ליישם‪‭‬‬
           ‫‬שתרצה‪‭‬‬
      ‫‬לעדכן‪‭‬‬          ‫‬מראש‪‬‭‬כל‪‭‬‬
                 ‫‬את‪‬‭‬השורות‪‭‬‬

                                 ‫15‬
    ‫‬היחלצות‪‬ ‭‬של‪‬ ‭‬ללא‪‭‬‬
‫‬ממצב‪‬ ‭‬נעילה‪‬ ‭‬מוצא‪‭‬‬
             ‫•‬                          ‫לא‪‭‬‬
                                  ‫‬מוצא‪- ‭‬‬
     ‫‬קובעת‪‬ ‭‬המתנה‪* RDBMS ‭‬‬
‫‬מערכת‪‭‬‬              ‫)‪‬ (Time Out‬זמן‪‭‬‬
         ‫‬כך‪‬ ‭‬תוכנית‪‬ ‭‬ממתינה‪‬ ‭‬לו‪‭‬‬
    ‫‬תופסק‪‭‬‬‫‬מעבר‪‭‬‬      ‫‬שאם‪‬ ‭‬יישום‪‭‬‬
      ‫‬של‪‬ ‭‬יישום‪‬‭‬שהיא‪‬ ‭‬כדי‪‭‬‬
 ‫‬פעולתה‪‬ ‭‬תוכנית‪‬ ‭‬כל‪‬ ‭‬תוך‪‬ ‭‬ביצוע‪‭‬‬
       ‫‬שהתוכנית‪Rollback ‭‬‬
  ‫‬פעולה‪‭‬‬                       ‫‬כל‪‭‬‬
                        ‫‬וביטול‪‬‭‬העדכונים‪‭‬‬

              ‫‬שפעולתה‪‭‬‬
        ‫‬תופסק‪:‭‬‬            ‫‬לבחירת‪‭‬‬
                     ‫‬התוכנית‪‭‬‬    ‫קריטריון‪‭‬‬
                                  ‫ריטריון‪‭‬‬
                              ‫‬שהתחילה‪‭‬‬
                         ‫‬לפעול‪‭‬‬      ‫ונה‪‭‬‬
             ‫‬לבצע‪‬ ‭‬מעט‪‭‬‬      ‫‬התנועה‪‭‬‬
      ‫- ‬שהספיקה‪‬ ‭‬הכי‪‬ ‭‬עדכונים‪‭‬‬
                                     ‫25‬
     ‫‬בתהליך‪‭‬‬
‫‬עדכון‪‭‬‬          ‫‬בעיית‪‬ ‭‬רשומה‪‭‬‬
           ‫‬עדכון‪‬ ‭‬שנמצאת‪‭‬‬
                  ‫-‬
             ‫‬דוגמא‪‭‬‬
        ‫‬תוכנית‪‭‬‬        ‫‬קוראת‪‬ ‭‬של‪‭‬‬
  ‫002-‪‬ C‬שורה‪‬ ‭‬קורס‪‬ TR1 ‭‬יישום‪• ‭‬‬
                      ‫‬ומעדכנת‪‭‬‬
                  ‫‬אותה‪‭‬‬           ‫‬מטבלת‪“ ‭‬‬
                             ‫‬קורסים‪”‭‬‬
          ‫‬תוכנית‪‭‬‬        ‫‬את‪‬ ‭‬של‪‭‬‬
   ‫‬קוראת‪‬‭‬השורה‪‬ ‭‬מחלקת‪‬ TR2 ‭‬יישום‪• ‭‬‬
          ‫‬מחלקות‪‬ ,”‭‬את‪‬ ‭‬של‪‭‬‬
   ‫‬קוראת‪‬‭‬השורה‪‬ ‭‬קורס‪CS ‭‬‬       ‫‬מטבלת‪“ ‭‬‬
       ‫‬את‪C-200 ‭‬‬      ‫‬ולבסוף‪‭‬‬
                 ‫‬קורסים‪‬ ”‭‬מעדכנת‪‭‬‬‫‬מטבלת‪“ ‭‬‬
                 ‫‪‬ CS‬של‪‭‬‬
          ‫‬מחלקות‪‬ ‭‬השורה‪‬ ‭‬מחלקת‪‭‬‬      ‫”‬
                                  ‫‬בטבלת‪“ ‭‬‬



                                       ‫35‬
     ‭‫‬בתהליך‬
‭‫‬עדכון‬          ‭‫ ‬רשומה‬‭‫‬בעיית‬
           ‭‫ ‬שנמצאת‬‭‫‬עדכון‬
                  -
             ‭‫‬דוגמא‬
                                 • TR1
            • SELECT (C-200) COURSES
           • UPDATE (C-200) COURSES
                                 • TR2
        • SELECT (CS) DEPARTMENTS
             • SELECT (C-200) COURSES
    •     UPDATE (CS) DEPARTMENTS

                                     54
     ‫ע”י‬      ‫‪‬ RDBMS‬לניהול‪‭‬‬
‫‬דוגמא‪‬ ‭‬נעילות‪‬ ‭‬מערכת‪‭‬‬




                               ‫55‬
     ‫ע”י‬      ‫‪‬ RDBMS‬לניהול‪‭‬‬
‫‬דוגמא‪‬ ‭‬נעילות‪‬ ‭‬מערכת‪‭‬‬




                               ‫65‬
          ‭‫‬גירסאות‬
       Framework – Hibernet‭‫‬מתוצרת‬
• ‭‫‬מערכת‬
                           Apache
                        ‭‫‬מונחית‬
                 • ‭‫ ‬עצמים‬‭‫‬סביבה‬
                             JAVA
                       • ‭‫‬שפת‬
                         ‭‫‬בסיס‬
                 • ‭‫ ‬נתונים‬Oracle
      • -‫ ה‬Framework             ‭‫עבודה‬
                               ‭‫‬עם‬
       )SELECT ,UPDATE‭‫( ‬הנתונים‬
                                 57
    ‫‬מספר‪‭‬‬     ‫‬מספר‪‭‬‬
‫‬גירסאות‪‬ – ‭‬עדכני‪ ‭‬ו- ‬שוטף‪‭‬‬

                 ‫‬לכל‪‬ ‭‬בטבלה‪‬ ‭‬מספר‪‭‬‬
        ‫‬שורה‪‬ ‭‬נשמר‪‬ " ‭‬גרסה‪• "‭‬‬
       ‫‬קורא‪‭‬‬       ‫‬המבקש‪‬ ‭‬שורה‪‭‬‬
‫‬יישום‪‬ ‭‬לעדכן‪‬ ‭‬בטבלה‪‬ – ‭‬שורה‪• ‭‬‬
                      ‫‬מהדיסק‪) ‭‬‬
               ‫‬בעזרת‪ ‭‬ה-‬    ‫(‪Framework‬‬
             ‫‬היישום‪) ‭‬‬
   ‫‪‬ Framework‬בעזרת‪ ‭‬ה- •‬            ‫‪ ‭‬ב- 1‬
                ‫‬את‪ ‭‬ה- " ‬הגרסה‪‬ "‭‬שורת‪‭‬‬
          ‫‬של‪‬ ‭‬הטבלה‪‭‬‬        ‫‬מספר‪‭‬‬
  ‫•‬                ‫שומר‪‬ ‭‬השורה‪‬ ‭‬העבודה‪‭‬‬
               ‫‬שלו‪‭‬‬     ‫‪‬ ‭‬את‪‬ ‭‬בשטח‪‭‬‬
                ‫‪RAM‬ב-‬                 ‫ה‪– "‭‬‬
                          ‫‬מספר‪‬ ‭‬של‪‭‬‬
                   ‫" ‬גירסה‪‬ ‭‬היישום‪"‭‬‬

                                    ‫85‬
            ‫‬עדכון‪‭‬‬
        ‫‬גירסאות‪‬ – ‭‬שורה‪‭‬‬
        ‫‬כאשר‪‬ ‭‬מבקש‪‬ ‭‬רשומה‪‬ ‭‬מבצע‪‭‬‬
‫‬יישום‪‬ ‭‬לעדכן‪‬ ‭‬הוא‪‬ ‭‬פקודה‪• :‭‬‬
                        ‫‪• PDATE…WHERE‬‬
         ‫" ‬גרסה‪‬ ‭‬היישום‪‬ "= "‭‬הגירסה‪‬ ‭‬שורת‪‭‬‬
               ‫)‬
‫‬של‪‬ ‭‬הטבלה‪• "(‭‬‬      ‫‬מספר‪‭‬‬       ‫‬מספר‪‬ ‭‬של‪‭‬‬
               ‫‬מתחיל‪‭‬‬
         ‫‬היישום‪‬ ‭‬מחדש‪• ‭‬‬       ‫‬אם‪‬ ‭‬אינו‪‭‬‬
                          ‫‬השוויון‪‬ ‭‬מתקיים‪‭‬‬
              ‫‬ונרשמה‪‭‬‬
       ‫‬פקודת‪• ‭‬‬          ‫‬השוויון‪‭‬‬
                    ‫‬מתקיים‪‭‬‬       ‫‪Commit‬‬
                                 ‫‬אם‪‭‬‬
                                       ‫‬העדכון‪‭‬‬
                                 ‫‬יתבצע‪‭‬‬



                                          ‫95‬
    ‫‬לאותו‪‭‬‬    ‫‬לרשום‪2 ‭‬‬
‫‬סטודנטים‪‬ ‭‬קורס‪‭‬‬            ‫‬דוגמא‪‬‭‬יישומים‪‭‬‬
                      ‫‬מבקשים‪‭‬‬     ‫:2‬
                 ‫- ‬העדכון‪‭‬‬
            ‫‬האבוד‪‭‬‬    ‫‬בעיית‪‭‬‬

               ‫= 5002-‪‬ C‬גירסה‪‬ ‭‬שורת‪‭‬‬
        ‫‬מספר‪‬ ‭‬של‪‬ ‭‬קורס‪• :‭‬‬
         ‫‬יישום‪ ‭‬א' ‬לעדכן‪‬ ‭‬לכן‪‬ ‭‬קורא‪‭‬‬
‫‬רוצה‪‬ ‭‬רשומה‪‬ ‭‬הוא‪‬ ‭‬רשומת‪• ‭‬‬
      ‫ל- 6‬      ‫‬ומעלה‪‬ ‭‬המספר‪‭‬‬
   ‫‬מהדיסק‪‬ ‭‬את‪‬ ‭‬הגרסה‪‬ ‭‬כך‪‭‬‬      ‫‬הקורס‪‭‬‬
        ‫‬מצויה‪‬ ‭‬הרשומה‪‬‭‬גירסה‪RAM6 ‭‬‬
    ‫‬שב‪-‭‬‬          ‫‬עם‪‭‬‬     ‫‬שלו‪‬ ‭‬עותק‪‭‬‬
          ‫‬יישום‪ ‭‬ב' ‬לעדכן‪‬ ‭‬רשומה‪‬ ‭‬הוא‪‭‬‬
  ‫‬רוצה‪‬ ‭‬אותה‪‬ ‭‬לכן‪‬ ‭‬קורא‪• ‭‬‬
             ‫‬מעלה‪‬ ‭‬מספר‪‭‬‬    ‫‬רשומה‪‭‬‬
  ‫‬אותה‪‬ ‭‬מהדיסק‪‬ ‭‬את‪‬ ‭‬הגרסה‪ ‭‬ל- 7‬
             ‫‬כך‪‭‬‬
         ‫‬שב‪-‭‬‬‫‪RAM‬‬            ‫ויה‪‬ ‭‬הרשומה‪‭‬‬
                           ‫‬עם‪‭‬‬     ‫‬עותק‪‭‬‬
                                  ‫‬גירסה‪7 ‭‬‬

                                        ‫06‬
    ‫‬לאותו‪‭‬‬    ‫‬לרשום‪2 ‭‬‬
‫‬סטודנטים‪‬ ‭‬קורס‪‭‬‬           ‫‬יישומים‪‭‬‬
                      ‫‬מבקשים‪‭‬‬    ‫דוגמא‪2 :‭‬‬

          ‫‬מבצע‪‭‬‬     ‫‬היישום‪‭‬‬
  ‫‬לא‪‬ UPDATE ‭‬הראשון‪‬ ‭‬פקודת‪• ‭‬‬      ‫‬אשר‪‭‬‬
                ‫‬מספר‪‭‬‬ ‫‬תתבצע‪‭‬‬
        ‫‪‬ RAM‬כי‪‬ ‭‬הגרסה‪ ‭‬ב-‬              ‫נה‪6 ‭‬‬
                                  ‫סה‪‬ "‭‬השורה‪‭‬‬
                            ‫‬של‪‬ ‭‬הינו‪7 ‭‬‬
                         ‫‬היישום‪‬ ‭‬להתבצע‪‭‬‬
                   ‫‬מחדש‪(‭‬‬     ‫) ‬יתחיל‪‭‬‬
        ‫‬היישום‪‬ ‭‬מבצע‪‭‬‬
 ‫‬תתבצע‪‬ UPDATE ‭‬השני‪‬ ‭‬פקודת‪• ‭‬‬      ‫‬אשר‪‭‬‬
                  ‫‬מספר‪‭‬‬
                       ‫‪RAM‬‬
         ‫‬כי‪‬ ‭‬הגירסה‪ ‭‬ב-‬                  ‫‪7‭‬‬
                                       ‫‬הזהה‪‭‬‬
                         ‫‬של‪‭‬‬      ‫‬מספר‪‭‬‬
                    ‫ל- " ‬הגירסה‪‬ "‭‬השורה‪‭‬‬



                                        ‫16‬
        ‫‬עדכון‪‬ ‭‬שנמצאת‪‭‬‬
  ‫‬בתהליך‪‭‬‬    ‫‬בעיית‪‬ ‭‬רשומה‪‭‬‬
        ‫)‪(Uncommitted Update‬‬
   ‫‬עדכון‪‭‬‬
                             ‫= 5002-‪‬ C‬גירסה‪‬ ‭‬שורת‪‭‬‬
                      ‫‬מספר‪‬ ‭‬של‪‬ ‭‬קורס‪• :‭‬‬
                        ‫‬רוצה‪‬ ‭‬רשומה‪‬ ) ‭‬נרשמים‪‭‬‬
 ‫‬מכסימלי‪ ‭‬מ- 58 ל- 59( •‬      ‫‬מספר‪‭‬‬     ‫‬יישום‪ ‭‬א' ‬לעדכן‪‭‬‬
                          ‫‬ומעלה‪‬‭‬המספר‪‭‬‬       ‫קורא‪‬ ‭‬הקורס‪‭‬‬
                ‫‪‬ ‭‬רשומת‪‬ ‭‬מהדיסק‪‬ ‭‬את‪‬ ‭‬הגרסה‪ ‭‬ל- 6‬
                     ‫‬מצויה‪‬ ‭‬הרשומה‪‬‭‬גירסה‪‬ 6 ‭‬כך‪‭‬‬
                 ‫‬שב‪-‭‬‬ ‫‪RAM‬‬         ‫‬עם‪‭‬‬     ‫‬שלו‪‬ ‭‬עותק‪‭‬‬
        ‫‬לכאורה‪‬ ‭‬כי‪‬ ‭‬הגרסה‪‬ UPDATE ‭‬מבצע‪‭‬‬
‫‬היישום‪‬ ‭‬פקודת‪• ‭‬‬                ‫‬מספר‪‭‬‬ ‫‬תתבצע‪‭‬‬    ‫‬אשר‪‭‬‬
                                    ‫‬של‪‭‬‬      ‫‬מספר‪‭‬‬
                       ‫‬זהה‪ ‭‬ל- " ‬הגירסה‪‬ "‭‬השורה‪RAM‭‬ב-‬
          ‫‬ואולם‪‬ ‭‬ולא‪‭‬‬            ‫‬אז‪‬‭‬תתבצע‪‬ ‭‬כתיבה‪‭‬‬
   ‫‬לא‪‬ ‭‬עדיין‪‬ ‭‬על‪‬ COMMIT‭‬מאחר‪‬ ‭‬בוצע‪• ‭‬‬            ‫‬כי‪‭‬‬
                     ‫‬הדיסק‪‭‬‬              ‫‪‬ (COMMIT‬עד‪‭‬‬
              ‫‬יחכה‪‬‭‬לפקודת‪ ‭‬ה- ‪‬ RDBMS‬ממש‪) ‭‬‬
               ‫‬עד‪‭‬‬      ‫‬מספר‪‭‬‬       ‫‬רוצה‪‬ ‭‬אותה‪‭‬‬
  ‫‬יישום‪ ‭‬ב' ‬לעדכן‪‬ ‭‬רשומה‪‬ ) ‭‬נרשמים‪‬‭‬כה‪ ‭‬מ- 83 ל- •‬
                        ‫‬של‪‭‬‬      ‫‬ללא‪‭‬‬      ‫3( ‬הוא‪‬ ‭‬רשומה‪‭‬‬
               ‫‬לכן‪‬ ‭‬קורא‪‬ ‭‬מהדיסק‪‬ ) ‭‬שינויים‪‬ ‭‬יישום‪ ‭‬א'(‬
       ‫‬כך‪‭‬‬          ‫‬מעלה‪‬‭‬מספר‪‭‬‬           ‫‬שלו‪‬ ‭‬עותק‪‭‬‬
    ‫‬מצויה‪‬ ‭‬הרשומה‪‬ RAM‭‬את‪‬ ‭‬הגרסה‪ ‭‬ל- 7‬שב‪-‭‬‬
                                                      ‫‬עם‪‭‬‬
                                                ‫‬גירסה‪7 ‭‬‬

                                                    ‫26‬
       ‫‬עדכון‪‬ ‭‬שנמצאת‪‭‬‬
 ‫‬בתהליך‪‭‬‬    ‫‬בעיית‪‬ ‭‬רשומה‪‭‬‬
       ‫)‪(Uncommitted Update‬‬
  ‫‬עדכון‪‭‬‬
         ‫‬מבצע‪‭‬‬     ‫‬היישום‪‭‬‬
 ‫‬אשר‪‬ ROLLBACK ‭‬הראשון‪‬ ‭‬פקודת‪• ‭‬‬
             ‫‬בעצם‪‬ ‭‬את‪‬ ‭‬הטבלה‪‭‬‬
   ‫‬של‪‬ RAM‭‬מוחק‪‬‭‬שורת‪‬ ‭‬מזיכרון‪ ‭‬ה-‬
                                 ‫‬ולא‪‭‬‬
                           ‫‬היישום‪‬ ‭‬מהדיסק‪‭‬‬
        ‫‬היישום‪‬ ‭‬מבצע‪‭‬‬
‫‬תתבצע‪‬ UPDATE ‭‬השני‪‬ ‭‬פקודת‪• ‭‬‬      ‫‬אשר‪‭‬‬
                 ‫‬מספר‪‭‬‬‫‪RAM‬‬
        ‫‬כי‪‬ ‭‬הגירסה‪ ‭‬ב-‬                  ‫‪7‭‬‬
                                     ‫‬הזהה‪‭‬‬
                        ‫‬של‪‭‬‬      ‫‬מספר‪‭‬‬
                   ‫ל- " ‬הגירסה‪‬ "‭‬השורה‪‭‬‬


                                      ‫36‬
            ‫‬תנועה‪‬‭‬מספר‪‭‬‬
     ‫‬עם‪‬ ‭‬עדכונים‪‭‬‬
                           ‫‬לדוגמא‪‬ :‭‬סטודנט‪‭‬‬
                   ‫‬רישום‪‬ ‭‬לקורס‪• ‭‬‬
         ‫•‬                        ‫‬עד‪‭‬‬
                               ‫‬שנרשמו‪‬‭‬כה‪"‭‬‬‫טים‪‭‬‬
                         ‫‬הוספת‪‬ ‭‬בטבלת‪" ‭‬‬
                   ‫‬ציונים‪"‭‬‬    ‫‬וכן‪‬ ‭‬שורה‪‭‬‬
       ‫‪‬ COMMIT‬שנרשמה‪‭‬‬
‫‬פקודת‪• ‭‬‬    ‫‬ברגע‪‭‬‬                       ‫עדכון‪‭‬‬
                                  ‫ל ‬ועדכון‪- ‭‬‬
    ‫‬בין‪‬ ‭‬הגירסה‪‬ ‭‬שורת‪‬ ‭‬עם‪‭‬‬
‫‬השוואה‪‬‭‬מספר‪‬ ‭‬של‪‬ ‭‬הטבלה‪‬‭‬מספר‪‭‬‬     ‫‬מתבצעת‪‭‬‬‫*‬


            ‫‪‬ * RAM‬ימחקו‪‬‭‬העדכונים‪‭‬‬
  ‫‬מזיכרון‪ ‭‬ה-‬      ‫‬אחרת‪‬ ‭‬כל‪‭‬‬
                            ‫‬היישום‪‬ ‭‬להתבצע‪‭‬‬
                       ‫‬מחדש‪‭‬‬     ‫* ‬יתחיל‪‭‬‬

                                         ‫46‬
                 ‫‬תרגילים‪‭‬‬
‫1. •‬           ‫‬לפחות‪‬ 2 ‭‬מדוע‪‬ ‭‬עלולה‪‭‬‬
        ‫‬סיבות‪‬ ‭‬תנועה‪‬ ‭‬להסתיים‪‭‬‬    ‫‬מנה‪‭‬‬

      ‫‬הסבר‪‬‭‬החשיבות‪‬ ‭‬קובץ‪‬ ‭‬האירועים‪‭‬‬
 ‫‬ואיזה‪‭‬‬      ‫‬של‪‬ ‭‬יומן‪‭‬‬      ‫2. ‬את‪‭‬‬

            ‫‬חווה‪‬ ‭‬על‪‬ ‭‬התקופה‪‬ ‭‬כדאי‪‭‬‬
       ‫‬שבה‪‬ ‭‬לשמור‪‭‬‬     ‫3. ‬דעתך‪‬‭‬אורך‪‭‬‬

        ‫4. ‬מהו‪‬ “ ‭‬לאחור‪‬ ”‭‬שיחזור‪‭‬‬
  ‫‬ומהו‪‬ “ ‭‬לפנים‪”‭‬‬    ‫‬הסבר‪‬ ‭‬שיחזור‪‭‬‬
                     ‫‬נדרש‪‬‭‬אחד‪‭‬‬
                  ‫‬ומתי‪‬ ‭‬כל‪‬ ‭‬מהם‪‭‬‬
                                      ‫56‬
                ‫‬תרגילים‪‭‬‬

                  ‫4 •‬
             ‫‬דן‪‬ ‭‬את‪‭‬‬
   ‫‬נעל‪‬‭‬האובייקטים‪‭‬‬     ‫,3‪*: R‬‬
                    ‫‬וממתין‪‬ R2, R1 ‭‬משתמש‪‭‬‬
                              ‫4‪‬ R‬לאובייקט‪‭‬‬
              ‫‬רון‪‬ ‭‬את‪‭‬‬    ‫,6‪R‬‬
  ‫‬וממתין‪‬ R5, R4 ‭‬משתמש‪‬‭‬נעל‪‬‭‬האובייקטים‪* ‭‬‬
                                         ‫8‪R‬‬
                                 ‫‬לאובייקט‪‭‬‬
           ‫01‪‬ R‬לאובייקט‪‬ R8 ‭‬משתמש‪‬ ‭‬נעל‪‭‬‬
‫‬אייל‪‬ ‭‬אובייקטים‪* ‭‬‬  ‫,9‪: R‬‬         ‫‬וממתין‪‭‬‬
             ‫‬וממתין‪ ‭‬ל 01‪‬ R‬משתמש‪‬ ‭‬נעל‪‭‬‬
  ‫‬צבי‪‬ ‭‬אובייקטים‪* ‭‬‬     ‫,11‪R‬‬             ‫2‪R‬‬
      ‫‬בא‪‬ ‭‬העובדה‪‬ ‭‬מצב‪‬ ‭‬נעילה‪‭‬‬
‫‬שזהו‪‬ ‭‬של‪‬ ‭‬הראה‪* ‭‬‬      ‫‬כיצד‪‬‭‬לביטוי‪‭‬‬
                                        ‫‬ללא‪‭‬‬
                                    ‫‬מוצא‪‭‬‬

                                           ‫66‬

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:13
posted:10/9/2013
language:Hebrew
pages:66