דלגו לתוכן הראשי
גאמא קוד

Windows

Task manager, Thread, Page file, Handle, Desktop

תהליכים ו-Threads, Task Manager, Handles, Page File וניהול זיכרון ב-Windows.

בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל

חומר לימוד

Task manager, Thread, Page file, Handle, Desktop: איך Windows מריצה, זוכרת ומציגה

הפרק עוסק בחמישה מושגים של Windows שנשענים זה על זה: Task Manager, Thread, Page File, Handle ו-Desktop. קשה להבין אחד מהם בלי לדעת משהו על האחרים, ולכן נבנה אותם בסדר שבו כל שלב מניח את הקרקע לשלב הבא.

  • Task Manager: איך מגיעים אליו, מה מראה כל לשונית, במה נבדלות דרכי הסיום של תהליך, איך משנים עדיפות ו-Affinity, ואיך מאבחנים עומס, דליפת זיכרון ותוכנה שנתקעה.
  • Thread: מה הוא חולק עם שאר ה-Threads של התהליך ומה שייך רק לו, לפי מה המתזמן של Windows בוחר מי ירוץ, מה זה Priority Boost, ולמה תוספת Threads יכולה דווקא להאט.
  • Page File: אילו דפים Windows מוציאה מה-RAM אל הדיסק, מה מודדים Commit charge ו-Commit limit, היכן קובעים את הגודל והמיקום של הקובץ ומה קורה כשהוא קטן מדי.
  • Handle: הערך שתהליך מחזיק כדי לפנות לאובייקט של הליבה, למה קובץ מסרב להימחק, איך מזהים דליפה ואילו כלים חושפים Handles פתוחים.
  • Desktop: איזה תהליך מצייר את שולחן העבודה, איפה התיקייה שלו בדיסק, מה תפקיד ה-Secure Desktop של UAC ומה נותנים Desktops וירטואליים.

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

הקוד בפרק כתוב ב-C מול WinAPI, ופקודות שורת הפקודה הן של Windows. הכל הורץ על מחשב Windows 10 עם 8 מעבדים לוגיים, והפלט שמוצג הוא מה שהתקבל בפועל; מספרי PID ו-TID משתנים בכל הרצה, ולכן אצלכם יופיעו ערכים אחרים.

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

רקע: תהליך, זיכרון ואובייקטים של הליבה

תוכנית, תהליך ו-PID

ההבחנה הראשונה היא בין מה ששוכב בדיסק לבין מה שרץ. קובץ כמו calc.exe הוא תוכנית (program): רצף הוראות שמחכה שמישהו יפעיל אותו. ברגע ההפעלה נוצר תהליך (process), כלומר מופע חי של אותה תוכנית.

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

כאן הופעלה פעמיים תוכנית קטנה בשם radio.exe, ואז נשאלה Windows אילו תהליכים בשם הזה קיימים:

Text
tasklist /FI "IMAGENAME eq radio.exe"
פלט

Image Name                     PID Session Name        Session#    Mem Usage
========================= ======== ================ =========== ============
radio.exe                     3744 Console                    1      3,236 K
radio.exe                    26600 Console                    1      2,896 K

שתי שורות, שם קובץ אחד, שני מספרי PID שונים. זה בדיוק מה שתראו ב-Task Manager כשפתוחים כמה חלונות של אותו דפדפן.

חזרה לתוכן העניינים

מרחב כתובות, RAM וזיכרון וירטואלי

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

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

על החלק שבדיסק נרחיב כשנגיע ל-Page File. בינתיים מספיק לזכור שהזיכרון שתהליך רואה הוא שלו בלבד, ושהמיפוי שלו לחומרה נתון בידי Windows.

חזרה לתוכן העניינים

הליבה, user mode ואובייקטים של הליבה

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

התוכנות שאתם מפעילים רצות ב-user mode, עם הרשאות מצומצמות. כשתוכנה צריכה שירות שרק הליבה יכולה לתת, היא קוראת לפונקציה של WinAPI, ממשק התכנות של Windows; למשל, CreateFile מבקשת מהליבה לפתוח קובץ.

את המשאבים שהליבה מנהלת עבור תהליכים מכנים אובייקטים של הליבה (kernel objects). קובץ פתוח הוא אובייקט כזה, וכך גם מפתח Registry, תהליך, Thread, Mutex ו-Event.

כל אחד מחמשת המושגים של הפרק נוגע בחלק אחר של התמונה הזו:

מושגמה הואאיך הוא מתחבר לרקע
Task Managerכלי מובנה שמראה מה רץ וכמה משאבים כל דבר צורך, ומאפשר לפעול על תהליכיםמציג את התהליכים, את ה-PID שלהם ואת צריכת הזיכרון
Threadמי שמריץ בפועל את הקוד בתוך תהליך. המתזמן מחלק זמן מעבד ל-Threadsפועל בתוך מרחב הכתובות של התהליך שלו
Page Fileקובץ בדיסק שמחזיק זיכרון פרטי של תהליכים כשאין לו מקום ב-RAMהחלק של הזיכרון הווירטואלי שנמצא בדיסק
Handleערך שהליבה מוסרת לתהליך כדי שיוכל לפנות לאובייקט שלההדרך של קוד ב-user mode להשתמש באובייקט של הליבה
Desktopהסביבה הגרפית שבה החלונות מופיעיםיש לו צד של אובייקט מערכת וגם תיקייה בדיסק
חזרה לתוכן העניינים

Task Manager: לראות ולשלוט במה שרץ

איך פותחים אותו ולמה הוא קיים

Task Manager, בעברית מנהל המשימות, מגיע מובנה עם Windows. הקובץ שמפעיל אותו נקרא taskmgr.exe ויושב בתיקייה C:\Windows\System32.

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

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

מה עושיםמה מתקבל
Ctrl+Shift+Escהחלון של Task Manager, מיד וללא שלב ביניים
Ctrl+Alt+Deleteמסך האבטחה של Windows, עם נעילה, החלפת משתמש, יציאה ו-Task Manager. רק בחירה נוספת שם פותחת את הכלי
לחיצה ימנית על שורת המשימותתפריט קצר שאחד הפריטים בו הוא Task Manager
כתיבת taskmgr בחלון Run (Win+R) או בשורת הפקודההפעלה של taskmgr.exe

שני צירופים שנשמעים קרובים אינם קשורים אליו: Alt+Tab מדפדף בין החלונות הפתוחים, ו-Win+Pause מביא את דף המידע על המערכת.

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

כדאי לדעת גם מה לא תמצאו בו. ניהול קבצים ותיקיות שייך ל-File Explorer, סריקת וירוסים ל-Windows Security (Windows Defender), ופינוי קבצים זמניים ל-Disk Cleanup, ואילו מטמון של דפדפן מנקים בהגדרות הדפדפן. גם ההגדרה של כמה מקום יתפוס ה-Page File נעשית במקום אחר, ב-System Properties, ורשימה של עדכונים שהותקנו אינה מופיעה בו בכלל.
טעויות נפוצות
  • Ctrl+Alt+Delete הוא הקיצור שמקפיץ את Task Manager הצירוף הזה מביא מסך אבטחה, ו-Task Manager הוא רק אחד הפריטים בו. הקיצור הישיר הוא Ctrl+Shift+Esc.
  • דרך Task Manager מפנים מקום בכונן או מריצים בדיקת אבטחה את זה עושים Disk Cleanup ו-Windows Security. Task Manager מציג ומנהל תהליכים ומשאבים.
בדקו את עצמכם
העכבר לא זז, אבל המקלדת עובדת. איזה צירוף יביא אתכם ל-Task Manager בפעולה אחת?

Ctrl+Shift+Esc, שפותח את הכלי ישר, בלי מסך האבטחה.

מה תקלידו בחלון Run כדי להפעיל את מנהל המשימות, ואיזה קובץ ירוץ?

taskmgr, והקובץ שירוץ הוא taskmgr.exe מתוך System32.

חזרה לתוכן העניינים

הלשוניות ומה כל אחת מראה

ב-Windows 10 הלשוניות מסודרות בשורה בראש החלון. ב-Windows 11 הן עברו לתפריט צדדי, ושם הלשונית Startup הוא שם Startup apps.

לשוניתמה רואיםמה אפשר לעשות
Processesאפליקציות ותהליכי רקע, ולכל אחד אחוזי CPU, זיכרון, דיסק ורשתלמיין לפי כל עמודה, End task, להפעיל מחדש את Windows Explorer
Performanceגרפים חיים של המחשב כולו: מעבד, זיכרון, דיסק, רשת, וגם GPUרק צפייה. בגרף המעבד יש גם Show kernel times
App historyצריכת משאבים שהצטברה לאורך זמן, וכברירת מחדל רק של אפליקציות מהחנות (UWP)צפייה
Startupהתוכנות שעולות לבד בכניסת המשתמש, עם עמודת Startup impactDisable ו-Enable
Usersמי מחובר למחשב וכמה משאבים כל משתמש צורךSign off, Disconnect
Detailsשורה לכל תהליך: שם, PID, Status, User name, CPU, Memory, ועוד עמודות לבחירהSet priority, Set affinity, End task, End process tree, Create dump file, Analyze wait chain
Servicesהשירותים, ה-PID של כל אחד ומצבו (Running או Stopped)Start, Stop, Restart, ופתיחה של services.msc

Startup ו-Details נוספו ב-Windows 8. ב-Windows 7, למשל, היו במקומן הלשוניות Applications ו-Processes, ואת התוכנות שעולות בהפעלה ניהלו בכלי נפרד, msconfig.

כדי לבחור לשונית, שאלו מה אתם מחפשים. מחפשים אשם, תהליך מסוים שתופס משאב? צריך טבלה של תהליכים, כלומר Processes או Details. רוצים לדעת עד כמה המחשב כולו לחוץ? Performance היא התשובה, ושום תהליך בודד לא מופיע בה בשמו.
טעויות נפוצות
  • כדי לגלות איזה תהליך זולל הכי הרבה, נכנסים ל-Performance Performance מציגה רק גרפים וסכומים של המערכת כולה. דירוג לפי תהליך רואים במיון של Processes או Details.
  • גרף נפרד לכל ליבה מופיע בלשונית Processes Processes היא טבלה. הגרפים, כולל הפירוק לליבות, נמצאים ב-Performance.
  • ב-Startup אפשר לעדכן קבצי מערכת או לקבוע כמה מקום יתפוס ה-Page File (קובץ ההחלפה) Startup עוסקת רק בתוכנות שמופעלות בכניסה. ה-Page File מוגדר ב-System Properties, ועדכונים אינם עניין של Task Manager.
  • לשונית Users מפרטת זמן מעבד לכל Thread Users מסכמת לפי משתמש מחובר. פירוט לפי Thread אין באף לשונית.
בדקו את עצמכם
רוצים לבדוק אם כרטיס הרשת של המחשב עמוס עכשיו, בלי לחפש אשם. לאן הולכים?

ל-Performance, ובוחרים בצד את Wi-Fi או Ethernet.

איפה תמצאו את ה-PID של שירות?

בלשונית Services יש עמודת PID. אפשר לראות אותו גם ב-Details, אם יודעים איזה תהליך מארח את השירות.

חזרה לתוכן העניינים

Details: העמודות שחשוב להכיר

ב-Details כל תהליך תופס שורה, והמידע טכני יותר מאשר ב-Processes. אלה העמודות שמופיעות בלי שנגעתם בדבר:

עמודהמה היא מראה
Nameשם קובץ ה-exe שממנו התהליך נוצר
PIDמספר הזיהוי של התהליך, והדרך להבדיל בין שני תהליכים בעלי אותו שם
StatusRunning, Suspended, או Not responding כשהתהליך הפסיק להגיב
User nameהחשבון שבשמו התהליך רץ, למשל SYSTEM או yossi
CPUאחוז הניצול של המעבד ברגע זה
Memoryהזיכרון הפיזי הפרטי שהתהליך מחזיק

כדי להוסיף עמודה, לוחצים לחיצה ימנית על שורת הכותרות ובוחרים Select columns. ברשימה שנפתחת מסמנים את מה שרוצים ומאשרים ב-OK.

זו הדרך היחידה. אין מתג של taskmgr בשורת הפקודה שעושה את זה, אין לשונית Handles בחלון ה-Properties של תהליך, ואין ערך Registry שעורכים לשם כך.

עמודהמה היא סופרתלמה מסתכלים עליה
Threadsכמה Threads יש לתהליך ברגע זהלהשוות בין תהליכים לפי מספר ה-Threads
Handlesכמה Handles התהליך מחזיק פתוחים עכשיו: קבצים, מפתחות Registry, Threads, Mutex ועודערך שמטפס בלי הפסקה רומז על דליפת Handles
GDI objectsכמה משאבים גרפיים של GDI התהליך יצר ועדיין מחזיק: גופנים (fonts), עטים (pens), מפות סיביות (bitmaps), מברשות (brushes) וגם הקשרי התקן (device contexts)עלייה מתמשכת רומזת שהתוכנה אינה משחררת משאבי ציור
USER objectsחלונות, תפריטים ופקדים של התהליךעמודה נפרדת מ-GDI objects, ואין לערבב ביניהן
Commit sizeהזיכרון הפרטי שהתהליך הקצה (Committed)מודדת זיכרון, ולא מספר אובייקטים
CPU timeזמן המעבד שהצטבר מאז שהתהליך התחילעולה בכל תהליך שעובד, ולכן עלייה בה לבדה אינה סימן לבעיה

לחיצה ימנית על שורה של תהליך, ולא על הכותרת, פותחת תפריט פעולות:

  • Open file location: פותח את התיקייה שבה שמור קובץ ה-exe.
  • Set priority: בוחר את מחלקת העדיפות של התהליך.
  • Set affinity: בוחר על אילו ליבות מותר לתהליך לרוץ.
  • End task: עוצר את התהליך מיד. ב-Windows 7 אותו פריט נקרא End process.
  • End process tree: עוצר את התהליך ואת כל התהליכים שהוא הפעיל.
  • Analyze wait chain: מראה למה התהליך מחכה.
  • Create dump file: כותב לקובץ את תמונת הזיכרון של התהליך, לניתוח מאוחר יותר.

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

תרחיש 1: עשרים שורות של msedge.exe

ברשימה של Details יש עשרים שורות בשם msedge.exe, ואתם רוצים לסגור רק את זו שמנפחת את הזיכרון.

לחיצה על הכותרת Memory ממיינת את הטבלה, והתהליך הכבד עולה לראש. בעמודה PID שלו כתוב, נניח, 9316, ובשורה שמתחתיו 2240, וכך אתם יודעים בוודאות על איזו שורה אתם פועלים.

Handles או Threads לא היו עוזרות כאן. הן מונות דברים שנמצאים בתוך כל תהליך, ואינן מזהות אותו.

טעויות נפוצות
  • עמודה חדשה מוסיפים מחלון ה-Properties של התהליך, או בהפעלה של taskmgr עם מתג עמודות מוסיפים רק בלחיצה ימנית על שורת הכותרות, דרך Select columns.
  • עמודת Handles מונה את החלונות של התהליך, או רק את חיבורי הרשת שלו היא מונה כל מה שרשום כרגע בטבלת ה-Handles של התהליך, מכל סוג של אובייקט ליבה.
  • הערך ב-Threads הוא כמה Threads התהליך יצר מאז שהתחיל זה מספר ה-Threads שקיימים עכשיו. Thread שהסתיים יורד מהספירה.
  • GDI objects מונה חלונות ותפריטים חלונות, תפריטים ופקדים נספרים ב-USER objects. ב-GDI objects נספרים כלי הציור: גופנים, מפות סיביות, עטים, מברשות והקשרי התקן.
  • GDI objects מודד זיכרון של כרטיס המסך, או כמה פעמים התוכנה ציירה המספר מייצג כלי ציור שהתהליך ייצר ועדיין לא החזיר. הוא לא נפח זיכרון ולא מונה של פעולות.
בדקו את עצמכם
תוכנת מצגות יוצרת מברשת חדשה בכל פעם שמציירים צורה, ולעולם אינה מוחקת אותה. איזה מספר יזחל למעלה ב-Details?

GDI objects, כי מברשת (brush) היא משאב GDI.

שתי שורות של svchost.exe נראות זהות. מה מבדיל ביניהן בוודאות?

ה-PID. השם משותף, אבל לכל תהליך יש מספר זיהוי משלו.

חזרה לתוכן העניינים

סיום תהליכים: End task ו-End process tree

אותו שם, End task, מופיע בשתי לשוניות, והתוצאה שונה. השאלה היא אם Windows קודם מבקשת מהתוכנה להיסגר, או פשוט עוצרת אותה.

פעולהלשוניתמה קורה בפועל
End taskProcessesקודם בקשה רגילה להיסגר, כמו לחיצה על ה-X של החלון. רק אם האפליקציה לא נענית, הסגירה נכפית
End task (ב-Windows 7: End process)Detailsעצירה מיידית, בלי לשאול את התוכנה. מה שלא נשמר הולך לאיבוד
End process treeDetailsעצירה מיידית של התהליך שנבחר ושל כל הצאצאים שלו, כלומר התהליכים שהוא הפעיל

End process tree עובר רק על העץ שמתחיל בתהליך שבחרתם. תהליך אחר של אותו משתמש, שלא נולד ממנו, לא נפגע:

תרחיש 2: עץ תהליכים בשורת הפקודה

לפעולה הזו יש מקבילה בשורת הפקודה: taskkill עם /T, שמוסיף את הצאצאים, ו-/F, שכופה סיום. כאן installer.exe (PID 19324) הפעיל שני תהליכי napper.exe, ובמקביל רץ editor.exe שהופעל בנפרד:

Text
taskkill /T /F /PID 19324
tasklist /FI "IMAGENAME eq napper.exe" /NH
tasklist /FI "IMAGENAME eq editor.exe" /NH
פלט
SUCCESS: The process with PID 17020 (child process of PID 19324) has been terminated.
SUCCESS: The process with PID 30548 (child process of PID 19324) has been terminated.
SUCCESS: The process with PID 860 (child process of PID 19324) has been terminated.
SUCCESS: The process with PID 19324 (child process of PID 15248) has been terminated.
INFO: No tasks are running which match the specified criteria.

editor.exe                   14628 Console                    1      2,896 K

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

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

לא כל תהליך אפשר לעצור בשלום. smss.exe, wininit.exe ו-csrss.exe הם חלק מהשלד של Windows, ובלעדיהם המערכת נופלת למסך כחול שהקוד שלו CRITICAL_PROCESS_DIED. מול תהליכים כאלה Task Manager מציג אזהרה, ולעיתים פשוט לא מאפשר.

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

להחזיר את Explorer. נעלמה שורת המשימות כי explorer.exe נסגר? ב-Task Manager בוחרים File ואז Run new task, ומקלידים את שם התוכנית; אותו פריט מפעיל כל תוכנית לפי שמה.

טעויות נפוצות
  • End process tree נותן לתהליך לשמור את העבודה ואז סוגר אותו בקשה להיסגר שייכת ל-End task שבלשונית Processes. End process tree ב-Details עוצר מיד, בלי לשאול.
  • End process tree מנקה את כל מה שהמשתמש הריץ הוא עוצר רק את התהליך הנבחר ואת מי שנולד ממנו.
  • תוכנה שסיימתם לא תעלה בכניסה הבאה הסיום פועל רק עכשיו. כדי למנוע עלייה אוטומטית משתמשים ב-Disable בלשונית Startup.
  • כל סיום של תהליך מסכן אתחול של המחשב רק תהליכים קריטיים, כמו csrss.exe או lsass.exe, מפילים או מאתחלים את המערכת.
בדקו את עצמכם
בדפדפן יש טופס ארוך שעוד לא נשלח, והדפדפן איטי. איזו דרך סיום נותנת לו הזדמנות להציג הודעה לפני שהוא נסגר?

End task בלשונית Processes, כי הוא מתחיל בבקשה לסגירה רגילה ורק אחר כך כופה.

Explorer נסגר ושורת המשימות נעלמה. איך מחזירים אותו מתוך Task Manager?

בתפריט File בוחרים Run new task וכותבים explorer.exe.

חזרה לתוכן העניינים

Set priority ו-Set affinity

כל תהליך שייך למחלקת עדיפות (Priority Class). המחלקה קובעת מאיזו עדיפות בסיס ה-Threads שלו מתחילים, וכך היא משפיעה על מי יקבל את המעבד ראשון כשכמה Threads מתחרים.

את המחלקה משנים ב-Details, בלחיצה ימנית על התהליך ובחירה ב-Set priority. לפני שהשינוי נכנס לתוקף Task Manager מבקש אישור, ומזהיר ששינוי כזה בתהליכים מסוימים עלול לערער את יציבות המערכת.

שש המחלקות, מהעליונה לתחתונה:

  1. Realtime: העליונה מכולן
  2. High
  3. Above normal
  4. Normal: ברירת המחדל של כמעט כל תהליך
  5. Below normal
  6. Low: התחתונה

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

אם תהליך כזה מחשב בלי הפסקה, גם ה-Threads של Windows שקולטים את העכבר והמקלדת מחכים לו. מבחוץ זה נראה כמו מחשב קפוא.

הגדרהמה היא קובעתמה היא לא קובעת
Set priorityמי מבין ה-Threads המוכנים יקבל את המעבד ראשוןכמות זיכרון, הרשאות מנהל, על אילו ליבות לרוץ, ואם התוכנה תעלה בכניסה הבאה
Set affinityעל אילו ליבות ה-Threads של התהליך יכולים לרוץ (בהתחלה כולן מותרות)מי קודם למי בתור

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

תרחיש 3: גיבוי שגונב את המעבד

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

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

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

טעויות נפוצות
  • High היא המחלקה העליונה מעליה יש Realtime, וזו המחלקה המסוכנת.
  • עדיפות גבוהה מעניקה לתהליך יותר זיכרון עדיפות קובעת רק מי מקבל זמן מעבד קודם. הזיכרון לא מושפע.
  • Realtime הופכת את התהליך למנהל, או מצמידה אותו לליבה אחת הרשאות מנהל מגיעות דרך UAC, ובחירת ליבות היא Affinity, הגדרה נפרדת.
  • את העדיפות משנים בלשונית Performance Performance נועדה לצפייה בלבד. Set priority נמצא בתפריט של תהליך בלשונית Details.
בדקו את עצמכם
במה שונה Set affinity מ-Set priority?

Set affinity מגביל על אילו ליבות מותר לרוץ. Set priority קובע מי מקבל את המעבד קודם כשיש תחרות.

משחק הועבר ל-Realtime, ומאז העכבר נתקע מדי פעם. למה?

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

חזרה לתוכן העניינים

Startup: מה עולה מעצמו בכניסה

נניח שתוכנת צ'אט עולה בכל כניסה ומעכבת את שולחן העבודה. בלשונית Startup, שנוספה ב-Windows 8, יש לה שורה עם השם שלה, היצרן, מצב (Enabled או Disabled) וציון Startup impact, High, Medium או Low, שמעריך כמה היא מאטה את העלייה.

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

מה עושיםמה משתנה מידמה קורה בכניסה הבאה
Disable ב-Startupכלום, תוכנה שרצה ממשיכה לרוץהתוכנה לא עולה מעצמה
End task או End process treeהתהליך נעצרהתוכנה עולה כרגיל
Set priority ל-Lowפחות זמן מעבד לתהליךהתוכנה עולה כרגיל
Stop בלשונית Servicesהשירות נעצרסוג ההפעלה של השירות לא השתנה, ושירות שמוגדר Automatic יעלה שוב
טעויות נפוצות
  • סיום התוכנה ב-Details מונע ממנה לעלות בפעם הבאה הסיום תקף לרגע הזה בלבד. רק Disable ב-Startup משנה את מה שקורה בכניסה.
  • ב-Startup מסדרים חלונות או קובעים את ה-Page File הלשונית מנהלת רשימה אחת בלבד: התוכנות שמופעלות בכניסה.
בדקו את עצמכם
סימנתם Disable ליישום שיחות וידאו. האם הוא הוסר מהמחשב?

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

חזרה לתוכן העניינים

Performance: גרפים של המחשב כולו

Performance מציירת גרפים שמתעדכנים ברציפות, ומה שהם מודדים הוא הניצול הכולל של משאבי המחשב. בצד בוחרים את המשאב: המעבד (CPU), הזיכרון (Memory), הדיסק, הרשת (Ethernet או Wi-Fi) ו-GPU.

בחרו בצד CPU. מעבר לגרף, שמציג את אחוז ה-Utilization ואת המהירות, יש בדף שלושה מספרים, Processes, Threads ו-Handles, ולידם Up time: הזמן שחלף מאז שהמחשב הודלק בפעם האחרונה.

שלושת המספרים הם סכומים של המערכת כולה. מי שמחפש כמה Threads או Handles יש לתהליך אחד צריך לעבור ל-Details ולהוסיף עמודה.

Show kernel times. המעבד עובד בשני כובעים: בחלק מהזמן הוא מבצע את התוכנות עצמן (user mode), ובחלק אחר את Windows ואת הדרייברים (kernel mode). את החלוקה הזו אפשר לצבוע בגרף של ה-CPU: קליק ימני על הגרף עצמו, Show kernel times, וזמן הליבה מופיע בתוכו בגוון כהה יותר.

זה המקום היחיד. מי שמחפש את האפשרות בכותרת של עמודה ב-Processes או ב-Details, או בגרף של Memory, לא ימצא אותה.

בדף של Memory יש כמה שדות:

שדהמה הוא אומר
In useRAM שתפוס כרגע
AvailableRAM שאפשר לתת מיד למי שיבקש
Committedזוג מספרים X/Y: כמה זיכרון כבר הוקצה (Commit charge) מתוך התקרה (Commit limit). נרחיב בחלק על Page File
Cachedזיכרון שמחזיק עותקים של קבצים מהדיסק לגישה מהירה
Paged poolזיכרון של הליבה שמותר להוציא ל-Page File
Non-paged poolזיכרון של הליבה שלעולם אינו עוזב את ה-RAM
Performance היא חלון צפייה. אין בה הגדרה של ה-Page File, אין בה Set priority, ואין בה סיום תהליכים.
טעויות נפוצות
  • Show kernel times מפעילים מכותרת עמודת ה-CPU ב-Processes האפשרות נמצאת בתפריט של הכפתור הימני על הגרף של המעבד, בלשונית Performance.
  • תחת CPU ב-Performance יש פירוט של Threads לכל תהליך שם מופיע מספר אחד: הסכום של המחשב כולו.
  • Performance מציגה את העדכונים האחרונים, או מדרגת תוכנות לפי ההשפעה על העלייה עדכונים אינם מוצגים ב-Task Manager בכלל, ו-Startup impact שייך ללשונית Startup.
בדקו את עצמכם
כמה Handles פתוחים עכשיו בכל המחשב יחד, ואיפה רואים את זה?

ב-Performance, בדף ה-CPU, במונה Handles.

רוצים לדעת כמה מזמן המעבד הולך לליבה ולדרייברים. מה עושים?

ב-Performance, בתפריט של הכפתור הימני על הגרף של המעבד, בוחרים Show kernel times.

חזרה לתוכן העניינים

שלושה מצבים לאבחון: עומס, דליפה ותקיעה

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

תלונהמה בודקיםמה מסיקים
המחשב איטיב-Processes ממיינים לפי CPU, Memory, Disk או Network, וב-Performance מסתכלים על אותו משאב ברמת המחשבProcesses מגלה את האשם, ו-Performance מראה כמה המשאב לחוץ בסך הכל. סגירת האשם מפנה את המשאבים מיד
תוכנה מתנפחת (Memory Leak)את עמודת Memory לאורך זמן, לא ברגע אחדדליפה היא זיכרון שמוקצה ולא מוחזר, ולכן היא נראית כקו שרק עולה. ערך גבוה ויציב אינו דליפה
תוכנה קפאה (Hung Process)סטטוס Not responding, ואז Analyze wait chain או Create dump fileמבינים למה ה-Threads מחכים לפני שמחליטים לסיים

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

תרחיש 4: ארבע מדידות בשעה

טכנאית רושמת את עמודת Memory של שני תהליכים, פעם בעשרים דקות:

תהליך14:0014:2014:4015:00
render.exe3,400 MB3,420 MB3,390 MB3,410 MB
syncd.exe90 MB260 MB430 MB610 MB

render.exe הוא הגדול, אבל הוא מתנדנד סביב אותו ערך. syncd.exe קטן ממנו בהרבה, ובכל זאת הוא מוסיף כ-170 MB בכל מדידה ואף פעם לא יורד, ולכן הוא החשוד.

למה לא לסגור מיד תוכנה שקפאה? תוכנה תקועה (Hung Process) מסומנת Not responding, וסגירה אכן משחררת אותה. אבל המחיר כפול: העבודה שלא נשמרה נעלמת, וכל עדות למה שקרה נעלמת איתה.

Analyze wait chain, מהתפריט של התהליך ב-Details, מגלה למה ה-Threads של התוכנה מחכים: לאירוע, או למשאב שנעול אצל Thread אחר, ומיהו המחזיק. הכלי מראה ולא נוגע: הוא לא סוגר תהליכים, לא משנה עדיפות ולא מודד זיכרון, ואתם מחליטים מה לעשות במה שגיליתם.

Create dump file הולך צעד עמוק יותר. הקובץ שנוצר מכיל את הזיכרון של התהליך ואת ה-stack של כל Thread שלו, וב-debugger רואים על איזו פקודה כל Thread עומד.

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

תרחיש 5: עורך וידאו שנתקע באמצע עבודה

עורך וידאו מסומן Not responding, ובפרויקט שלו שעתיים של עבודה שלא נשמרה.

Analyze wait chain ב-Details מראה שה-Thread הראשי של העורך מחכה לתהליך של תוסף כתוביות, וזה עצמו תקוע.

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

טעויות נפוצות
  • התהליך שמחזיק כרגע הכי הרבה זיכרון הוא זה שדולף גודל רגעי אינו סימן. מחפשים צריכה שממשיכה לטפס ולא יורדת.
  • Analyze wait chain משחרר את התקיעה בעצמו, סוגר את מי שבשרשרת או משנה עדיפויות הוא רק מציג מי מחכה למי. את הפעולה עושים אתם.
  • בודקים Threads לפני סיום כי סיום מיידי משאיר Handles פתוחים במערכת Windows סוגרת את כל ה-Handles של תהליך שהסתיים. הבדיקה נועדה להציל עבודה שלא נשמרה ולהבין מה גרם לתקיעה.
בדקו את עצמכם
תהליך מחזיק 95% CPU כבר חצי שעה, וה-Memory שלו לא זז. דליפת זיכרון?

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

למה Create dump file עדיף על סיום מיידי כשרוצים להבין תקיעה?

הקובץ שומר את ה-stack של כל Thread, וב-debugger רואים איפה כל אחד עומד, למשל Deadlock או לולאה אינסופית.

חזרה לתוכן העניינים

Thread: יחידת הביצוע

Thread: מי מריץ את הקוד, ומה משותף לו ולתהליך

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

מי שפועל הוא ה-Thread (תהליכון), היחידה הקטנה ביותר של ביצוע: הוא חי בתוך תהליך ומריץ את הקוד שלו בפועל. לכל תהליך יש לפחות Thread אחד, וברוב התוכנות יש כמה.

משותף לכל ה-Threads בתהליךשייך ל-Thread אחד בלבד
מרחב הכתובות: המשתנים הגלובליים, ה-heap והקודstack (מחסנית) משלו
טבלת ה-Handles: הקבצים הפתוחים, מפתחות ה-Registry וכל השארערכי האוגרים (registers) של המעבד
מחלקת העדיפות של התהליךמזהה משלו, Thread ID או בקיצור TID

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

ב-WinAPI יוצרים Thread בקריאה ל-CreateThread, שמקבלת את הפונקציה שה-Thread יריץ ומחזירה Handle אליו. התוכנית הבאה יוצרת שני Threads, עוצרת את שניהם מול אירוע (Event) ומשחררת אותם יחד, כך ששניהם חיים באותו זמן:

C
#include <windows.h>
#include <stdio.h>

volatile LONG scoreboard = 0;    /* global: one copy for the whole process */
HANDLE go;                       /* event: both threads start together */

DWORD WINAPI Player(LPVOID arg) {
    int local = (int)(INT_PTR)arg;   /* lives on this thread's own stack */
    WaitForSingleObject(go, INFINITE);
    InterlockedAdd(&scoreboard, local);
    printf("TID %lu: local=%d, &local=%p\n",
           GetCurrentThreadId(), local, (void*)&local);
    return 0;
}

int main(void) {
    HANDLE t[2];
    go = CreateEvent(NULL, TRUE, FALSE, NULL);   /* manual reset, not signaled */
    printf("PID %lu, main TID %lu\n", GetCurrentProcessId(), GetCurrentThreadId());
    t[0] = CreateThread(NULL, 0, Player, (LPVOID)5, 0, NULL);
    t[1] = CreateThread(NULL, 0, Player, (LPVOID)7, 0, NULL);
    SetEvent(go);                                /* both are alive now: release them */
    WaitForMultipleObjects(2, t, TRUE, INFINITE);
    printf("scoreboard=%ld\n", scoreboard);
    CloseHandle(t[0]); CloseHandle(t[1]); CloseHandle(go);
    return 0;
}
פלט
PID 23804, main TID 18404
TID 13716: local=7, &local=000000BB623FFD10
TID 21952: local=5, &local=000000BB621FFE90
scoreboard=12

ה-PID משותף, אבל לכל Thread יש TID אחר, וגם סדר ההדפסה לא מובטח: כאן דווקא ה-Thread של 7 הקדים. הכתובות של local רחוקות זו מזו כ-2 MB (...623FFD10 מול ...621FFE90), כי כל Thread רץ על stack נפרד, ואילו scoreboard הגלובלי קיבל את שתי התרומות והגיע ל-12.

ההוספה ל-scoreboard נעשית ב-InterlockedAdd ולא ב-+=, כי שני Threads כותבים לאותו משתנה באותו זמן. למה זה חשוב, נראה בחלק על Multithreading.

איך Thread מסתיים. יש ארבע דרכים:

  • הפונקציה שלו מגיעה ל-return, כמו Player בדוגמה.
  • הוא קורא בעצמו ל-ExitThread.
  • Thread אחר מפעיל עליו TerminateThread. זו דרך מסוכנת: ה-Thread נקטע בלי לשחרר מנעולים ומשאבים שהחזיק.
  • התהליך כולו מסתיים, ואיתו נגמרים כל ה-Threads שלו.
טעויות נפוצות
  • Thread הוא תהליך קטן עם זיכרון נפרד משלו זיכרון נפרד הוא סימן ההיכר של תהליך. Threads של אותו תהליך חיים באותו מרחב כתובות.
  • כל Thread מקבל העתק פרטי של הנתונים של התהליך אין העתק. הנתונים הגלובליים וה-heap אחד לכולם, ורק ה-stack פרטי.
  • Threads מעבירים מידע ביניהם דרך pipe או דרך ערך ב-Registry אין בזה צורך: הם קוראים וכותבים ישירות לאותו זיכרון. pipe משמש בין תהליכים נפרדים.
  • Thread הוא מספר שהמערכת נותנת כדי להצביע על משאב זה תיאור של Handle. Thread הוא מי שמריץ קוד.
  • Thread הוא האובייקט הגרפי שמייצג את שולחן העבודה זה Desktop, נושא אחר בפרק.
בדקו את עצמכם
Thread אחד פתח קובץ לוג וקיבל Handle. Thread שני באותו תהליך רוצה לכתוב לאותו לוג. האם מותר לו להשתמש באותו Handle?

כן. טבלת ה-Handles שייכת לתהליך, וכל ה-Threads שלו משתמשים בה.

מה מבין אלה אינו משותף ל-Threads של תהליך: ה-heap, המחסנית, הקוד או טבלת ה-Handles?

המחסנית. לכל Thread יש stack משלו, וגם אוגרים ו-TID משלו.

חזרה לתוכן העניינים

המתזמן: מי רץ עכשיו ועל איזו ליבה

ברגע נתון יש במחשב אלפי Threads ורק כמה ליבות. ההחלטה איזה Thread יקבל איזו ליבה, ולכמה זמן, היא של רכיב בליבת Windows שנקרא המתזמן (Scheduler).

כדאי להכיר את הכללים שלו אחד אחד, כי כל כלל נבדק בנפרד:

  • יחידת ההחלטה היא Thread. המתזמן לא מקצה זמן לתהליך כגוש אחד, וגם לא לחלון שנמצא בפוקוס.
  • מבין ה-Threads שמוכנים לרוץ, זוכה זה שהעדיפות שלו הכי גבוהה.
  • התזמון preemptive (מונע): כש-Thread בעדיפות גבוהה יותר נעשה מוכן, הוא מוציא מיד את ה-Thread הנמוך שרץ, גם אם לזה נותר עוד זמן מהתור שלו.
  • בין Threads שהעדיפות שלהם שווה, הליבה עוברת בסבב (Round Robin): כל אחד מקבל פרק זמן קצר שנקרא Quantum, ואז מגיע תורו של הבא.
  • העדיפות קובעת את סדר הקדימות, לא את אורך ה-Quantum.
  • כל הליבות הזמינות בשימוש, ו-Threads של אותו תהליך יכולים לרוץ באותו רגע על ליבות שונות.
  • Thread אינו קשור לליבה מסוימת. כשליבה מתפנה היא יכולה לקחת Thread שמחכה, גם אם קודם הוא רץ על ליבה אחרת.

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

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

התוכנית הבאה יוצרת 60 Threads במחשב עם 8 מעבדים לוגיים, וסופרת כמה Threads יש לה:

C
#include <windows.h>
#include <tlhelp32.h>
#include <stdio.h>

DWORD WINAPI Nap(LPVOID p) { Sleep(3000); return 0; }

static int count_my_threads(void) {          /* walk the system thread list */
    DWORD me = GetCurrentProcessId(); int n = 0;
    HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
    THREADENTRY32 te = { sizeof te };
    for (BOOL ok = Thread32First(snap, &te); ok; ok = Thread32Next(snap, &te))
        if (te.th32OwnerProcessID == me) n++;
    CloseHandle(snap);
    return n;
}

int main(void) {
    SYSTEM_INFO si; GetSystemInfo(&si);
    int made = 0;
    for (int i = 0; i < 60; i++)
        if (CreateThread(NULL, 0, Nap, NULL, 0, NULL)) made++;   /* handles freed at exit */
    printf("logical CPUs: %lu, threads created: %d\n", si.dwNumberOfProcessors, made);
    printf("threads in this process now: %d\n", count_my_threads());
    return 0;
}
פלט
logical CPUs: 8, threads created: 60
threads in this process now: 62

כל 60 נוצרו בלי תקלה. הספירה מגיעה ל-62 כי מלבדם יש את ה-Thread הראשי, ועוד Thread עזר אחד שהתוכנית לא יצרה בעצמה.

Context Switch. בכל פעם שליבה מחליפה Thread, Windows צריכה לארוז את ערכי האוגרים של היוצא ולפרוק את אלה של הנכנס. בזמן הזה שום קוד של תוכנה לא מתקדם, ולכן החלפות תכופות הן תקורה שמשלמים עליה בזמן מעבד.

תרחיש 6: שלושה Threads על ליבה אחת

על ליבה אחת ממתינים שלושה Threads מוכנים: X בעדיפות 12, ו-Y ו-Z בעדיפות 9.

X עולה ראשון. אחרי זמן קצר הוא שולח בקשה לרשת ונכנס להמתנה, ומרגע זה הוא לא מתחרה על הליבה.

Y ו-Z, ששווים בעדיפות, מתחלפים: Quantum ל-Y, Quantum ל-Z, וחוזר חלילה. כשהתשובה מהרשת מגיעה, X שוב מוכן ודוחק מיד את מי שרץ, אפילו באמצע ה-Quantum שלו.

טעויות נפוצות
  • Thread בעדיפות גבוהה מקבל פרוסת זמן ארוכה יותר העדיפות מחליטה מי עולה קודם. אורך ה-Quantum אינו נגזר ממנה.
  • Windows נותנת לכל Thread חלק שווה במעבד, בלי קשר לעדיפות סבב שווה קיים רק בין Threads באותה עדיפות. עדיפות גבוהה יותר תמיד קודמת.
  • Thread בעדיפות נמוכה עולה ראשון, כי הוא מחכה בתור יותר זמן הכלל הוא שהעדיפות הגבוהה קודמת. זמן ההמתנה אינו מקדים Thread נמוך על פני גבוה.
  • ה-Thread העליון רץ ברצף עד שהוא גומר את כל העבודה הוא רץ עד שהוא נכנס להמתנה, עד ש-Thread עליון ממנו דוחק אותו, או בסבב עם Threads בעדיפות שלו.
  • התור נקבע לפי הסדר שבו פתחתם את התוכנות סדר הפתיחה לא משחק תפקיד. העדיפות היא שקובעת.
  • כל ה-Threads של תוכנה רצים על אותה ליבה, או נשארים על הליבה שבה נוצרו הם יכולים לרוץ במקביל על כמה ליבות ולעבור בין ליבות לפי מה שמתפנה.
  • המתזמן מקצה זמן לתהליכים שלמים, או מעדיף את החלון הפעיל המתזמן עובד ברמת ה-Thread.
  • את התזמון מבצעת חומרת המעבד המתזמן הוא קוד של Windows שרץ בליבה של מערכת ההפעלה.
בדקו את עצמכם
במחשב יש 2 ליבות, ותוכנה פותחת 6 Threads, כולם בעדיפות Normal ומחשבים כל הזמן. האם זה אפשרי, ומה יקרה?

זה אפשרי. בכל רגע רצים לכל היותר 2 מהם, והם מתחלפים בסבבים של Quantum.

Thread בעדיפות נמוכה נמצא באמצע ה-Quantum שלו, ו-Thread בעדיפות גבוהה סיים להמתין. מתי הגבוה ירוץ?

מיד. התזמון preemptive, והנמוך נדחק בלי לחכות לסוף ה-Quantum.

חזרה לתוכן העניינים

עדיפות של Thread ו-Priority Boost

העדיפות של Thread מורכבת משני רכיבים. הראשון הוא מחלקת העדיפות של התהליך שלו, אחת משש המחלקות שראינו ב-Task Manager.

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

בתוכנית הבאה התהליך מעביר את עצמו ל-Below normal, יוצר שלושה Threads ונותן לשניים מהם עדיפות יחסית שונה. בזמן שהיא ממתינה, PowerShell מציג את ה-Threads שלה:

C
#include <windows.h>
#include <stdio.h>

DWORD WINAPI Idle(LPVOID p) { Sleep(6000); return 0; }   /* just waits */

int main(void) {
    SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS);

    HANDLE render   = CreateThread(NULL, 0, Idle, NULL, 0, NULL);
    HANDLE autosave = CreateThread(NULL, 0, Idle, NULL, 0, NULL);
    HANDLE logger   = CreateThread(NULL, 0, Idle, NULL, 0, NULL);
    SetThreadPriority(render, THREAD_PRIORITY_ABOVE_NORMAL);   /* +1 inside the class */
    SetThreadPriority(autosave, THREAD_PRIORITY_LOWEST);       /* -2 inside the class */

    printf("PID %lu, class 0x%lX\n", GetCurrentProcessId(),
           GetPriorityClass(GetCurrentProcess()));
    printf("relative: render=%d autosave=%d logger=%d\n",
           GetThreadPriority(render), GetThreadPriority(autosave), GetThreadPriority(logger));
    fflush(stdout);
    Sleep(5000);
    return 0;
}
פלט
PID 25476, class 0x4000
relative: render=1 autosave=-2 logger=0
Text
$p = Get-Process -Name prio
'Threads: ' + $p.Threads.Count + '  Handles: ' + $p.HandleCount + '  Class: ' + $p.PriorityClass
$p.Threads | Format-Table Id, BasePriority, PriorityLevel -AutoSize
פלט
Threads: 5  Handles: 70  Class: BelowNormal

   Id BasePriority PriorityLevel
   -- ------------ -------------
24880            6        Normal
26752            6        Normal
21048            7   AboveNormal
20288            4        Lowest
30444            6        Normal

הסתכלו על BasePriority. שלושה Threads שלא קיבלו עדיפות יחסית יושבים על 6, הבסיס של Below normal. ה-Thread שקיבל +1 עלה ל-7, וזה שקיבל -2 ירד ל-4: מחלקה אחת, שלוש עדיפויות שונות.

יש חמישה Threads כי לצד שלושת אלה יש את ה-Thread הראשי ו-Thread עזר אחד, כמו בדוגמה הקודמת. והמספר ב-Handles הוא מה שעמודת Handles ב-Details הייתה מראה לאותו תהליך.

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

וגבול חשוב: עדיפות היא רק מקום בתור למעבד. Thread בעדיפות שונה לא מקבל זיכרון נפרד, לא מנוע מלהשתמש ב-Page File ולא מקבל Desktop משלו.

Priority Boost. העדיפות שראינו היא הבסיס, ומעליו Windows יכולה להוסיף הרמה זמנית לעדיפות הדינמית של Thread. שני מקרים מוכרים:

  • אחרי קלט/פלט: Thread שחיכה, למשל, לבלוק מהדיסק, וקיבל אותו. Windows מקדמת אותו לזמן קצר כדי שיטפל בנתונים מיד, והתוכנה מרגישה זריזה.
  • נגד הרעבה (Starvation): Thread מוכן שלא זכה במעבד הרבה זמן, כי תמיד היה מישהו עליון ממנו. ההרמה נותנת לו סוף סוף לרוץ, כך ש-Thread נמוך לא נשאר בחוץ לנצח.

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

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

לזה שמצייר. עיכוב בו מורגש מיד על המסך, וההורדה יכולה לחכות לזמן פנוי.

תהליך ב-Normal, ואחד ה-Threads שלו קיבל Boost אחרי קריאה מהדיסק. מה המחלקה של התהליך עכשיו?

עדיין Normal. ה-Boost שייך ל-Thread בלבד, והוא זמני.

חזרה לתוכן העניינים

Multithreading: מתי זה עוזר ומתי זה פוגע

Multithreading פירושו לחלק את העבודה של תוכנה בין כמה Threads. יש לזה שתי תועלות ברורות:

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

כדאי לדעת מאיפה בא השיפור: מהליבות הנוספות ומהיכולת לא לעמוד בטל. אף ליבה לא מקבלת שעון מהיר יותר, אף Thread לא מקבל עותק זיכרון נפרד משלו, ומי שממשיך לתזמן הוא Windows ולא המעבד.

תרחיש 7: דחיסת תמונות על שמונה ליבות

תוכנה דוחסת אלפיים תמונות. עם Thread אחד זה לוקח 64 שניות, ועם 8 Threads, אחד לכל ליבה, הזמן יורד ל-9 שניות.

מתכנתת מנסה 200 Threads, והזמן דווקא עולה ל-12 שניות.

ואם כל ה-Threads מעדכנים מונה משותף שמוגן ב-mutex, מצטרף לזה גם זמן שבו Thread אחד מחכה לשני.

מה קרה במעבר מ-8 ל-200? כל ה-200 רוצים לרוץ, אבל רק 8 ליבות קיימות, ולכן המתזמן מחליף ביניהם כל הזמן. כל החלפה כזו היא Context Switch שאוכל זמן מעבד בלי לדחוס אף תמונה.

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

סנכרון. עכשיו לבעיה מסוג אחר, שנובעת דווקא מהיתרון של הזיכרון המשותף. בתוכנית הבאה שלושה Threads מוסיפים כל אחד 2,000,000 למונה אחד; שלושה סבבים בלי הגנה, וסבב אחד עם InterlockedIncrement, שמבצעת את ההוספה כצעד שאי אפשר לקטוע:

C
#include <windows.h>
#include <stdio.h>

#define ROUNDS  2000000
#define WORKERS 3
volatile LONG tickets = 0;       /* shared by all threads */

DWORD WINAPI SellUnsafe(LPVOID p) {
    for (int i = 0; i < ROUNDS; i++)
        tickets = tickets + 1;   /* load, add, store: another thread can slip in between */
    return 0;
}

DWORD WINAPI SellSafe(LPVOID p) {
    for (int i = 0; i < ROUNDS; i++)
        InterlockedIncrement(&tickets);   /* one indivisible step */
    return 0;
}

static void run(LPTHREAD_START_ROUTINE fn, const char *name) {
    HANDLE t[WORKERS];
    tickets = 0;
    for (int w = 0; w < WORKERS; w++) t[w] = CreateThread(NULL, 0, fn, NULL, 0, NULL);
    WaitForMultipleObjects(WORKERS, t, TRUE, INFINITE);
    for (int w = 0; w < WORKERS; w++) CloseHandle(t[w]);
    printf("%-7s expected %d, got %ld\n", name, WORKERS * ROUNDS, tickets);
}

int main(void) {
    for (int k = 0; k < 3; k++) run(SellUnsafe, "unsafe");
    run(SellSafe, "safe");
    return 0;
}
פלט
unsafe  expected 6000000, got 6000000
unsafe  expected 6000000, got 6000000
unsafe  expected 6000000, got 4472392
safe    expected 6000000, got 6000000

שימו לב לשלושת הסבבים הלא מוגנים: בהרצה הזו שניים הראשונים יצאו נכונים במקרה, והשלישי איבד כ-1.5 מיליון עדכונים. בהרצות אחרות יצאו מספרים אחרים, ולכן בדיקה אחת שעברה אינה מוכיחה שהקוד תקין; הגרסה המוגנת מגיעה ל-6,000,000 בכל פעם.

הסיבה: tickets = tickets + 1 היא בעצם שלוש פעולות, קריאה, הוספה וכתיבה. אם שני Threads קראו את אותו ערך לפני שאחד מהם כתב, שניהם כותבים את אותה תוצאה, ואחת ההוספות נמחקת.

מצב שבו התוצאה תלויה בסדר המקרי שבו ה-Threads רצו נקרא race condition. בתוכנה אמיתית הוא לא נגמר תמיד במספר שגוי: רשימה או תור משותפים עלולים להשתבש עד כדי קריסה.

Windows לא תתערב: היא לא מזהה את ההתנגשות, לא עוצרת את התוכנית ולא מעבירה את ה-Threads לריצה בתור. ההגנה באחריות המתכנת, בפעולה אטומית כמו בדוגמה או בנעילה כמו critical section או mutex, שדרכה רק Thread אחד ניגש לנתון בכל רגע.

טעויות נפוצות
  • יותר Threads חוסכים זיכרון, כי כולם משתמשים באותה מחסנית המחסנית היא בדיוק מה שלא משותף. כל Thread נוסף מוסיף stack.
  • כל Thread חדש מקבל ליבה פנויה נוספת מספר הליבות קבוע. Threads נוספים מתחלקים באותן ליבות.
  • Threads שלא תוכננו נכון רק מאטים את התוכנה הם עלולים להשחית נתונים ולגרום לקריסות, כפי שהמונה בדוגמה מראה.
  • Windows תזהה התנגשות בין Threads ותעצור את התוכנית לפני שייגרם נזק אין מנגנון כזה. המתכנת אחראי לנעילה.
בדקו את עצמכם
שני Threads דוחפים הזמנות לאותו תור בזיכרון, בלי שום נעילה. מה עלול לקרות?

race condition: הזמנות עלולות להיעלם, מבנה התור עלול להשתבש, והתוכנה עלולה לקרוס. הפתרון הוא נעילה, למשל mutex או critical section.

למה הוספת Threads מעבר למספר הליבות יכולה להאריך את זמן הריצה?

בכל רגע רץ רק Thread אחד על כל ליבה, והמתזמן מבזבז זמן על Context Switch בין כל השאר.

חזרה לתוכן העניינים

איפה רואים Threads, ב-Task Manager ומחוצה לו

Task Manager עובד ברמת התהליך, לא ברמת ה-Thread. זה מה שהוא כן מציע:

מה רוצים לדעתאיפה
כמה Threads יש לתהליך מסויםDetails, והוספה של העמודה Threads דרך Select columns
כמה Threads יש במחשב כולוPerformance, בדף ה-CPU
כמה CPU צורך Thread מסויםלא ב-Task Manager: לא ב-Details, לא ב-Performance ולא ב-Users

לפירוט לפי Thread צריך כלי אחר. Process Explorer, מחבילת Sysinternals של Microsoft, מציג אותו בחלון המאפיינים של תהליך, בלשונית Threads, וגם Performance Monitor יודע להציג מונים של Threads בודדים.

על שם מי נרשם העומס? התוכנית הבאה מודדת את זה ישירות: ה-Thread הראשי רק ממתין, Thread עובד מסתובב על המעבד שתי שניות, ובסוף GetThreadTimes ו-GetProcessTimes מדפיסות כמה זמן מעבד צבר כל אחד:

C
#include <windows.h>
#include <stdio.h>

static double ms(FILETIME f) {            /* FILETIME counts 100 ns units */
    ULARGE_INTEGER u; u.LowPart = f.dwLowDateTime; u.HighPart = f.dwHighDateTime;
    return u.QuadPart / 10000.0;
}

DWORD WINAPI Crunch(LPVOID p) {           /* worker: spins on the CPU for 2 s */
    DWORD start = GetTickCount();
    volatile unsigned long long x = 0;
    while (GetTickCount() - start < 2000) x++;
    return 0;
}

int main(void) {
    FILETIME c, e, k, u;
    HANDLE w = CreateThread(NULL, 0, Crunch, NULL, 0, NULL);
    WaitForSingleObject(w, INFINITE);     /* main thread just waits */

    GetThreadTimes(GetCurrentThread(), &c, &e, &k, &u);
    printf("main thread CPU:   %6.0f ms\n", ms(k) + ms(u));
    GetThreadTimes(w, &c, &e, &k, &u);
    printf("worker thread CPU: %6.0f ms\n", ms(k) + ms(u));
    GetProcessTimes(GetCurrentProcess(), &c, &e, &k, &u);
    printf("whole process CPU: %6.0f ms\n", ms(k) + ms(u));
    SYSTEM_INFO si; GetSystemInfo(&si);
    printf("logical CPUs: %lu\n", si.dwNumberOfProcessors);
    CloseHandle(w);
    return 0;
}
פלט
main thread CPU:       16 ms
worker thread CPU:   1656 ms
whole process CPU:   1672 ms
logical CPUs: 8

קראו את המספרים: לראשי 16 ms בלבד, לעובד 1656 ms, ולתהליך 1672 ms, שהם בדיוק החיבור של השניים. מכאן ש-Task Manager, שמציג רק תהליכים, יראה את התוכנה כולה עמוסה גם כשהחלון שלה רגוע; העובד לא מקבל שורה משלו, ואף תהליך אחר לא לוקח חלק מהעומס שלו.

ולמה העובד צבר פחות מ-2000 ms? באותן שתי שניות רצו על המחשב גם תוכנות אחרות, והמתזמן חילק ביניהן את הליבות.

ובאחוזים? Thread יחיד לא יכול לתפוס יותר מליבה אחת, ולכן במחשב הזה, עם 8 מעבדים לוגיים, Thread עמוס במלואו נראה כ-12.5% CPU לתהליך. לעומת זאת, תהליך עם כמה Threads עמוסים יכול לעבור ליבה אחת: שני Threads כאלה במחשב עם 4 ליבות יראו 50%.

תרחיש 8: חלון שקט ותהליך שעובד קשה

אפליקציית מוזיקה מציגה חלון שמחכה ללחיצה, וברקע Thread אחד עובר על כל הספרייה ומחשב את הקצב של כל שיר. במחשב יש 2 ליבות.

ב-Task Manager האפליקציה מראה כ-50% CPU, ליבה אחת מלאה מתוך שתיים. ה-Thread של החלון כמעט לא משתתף, אבל העומס נרשם על שם התהליך כולו.

טעויות נפוצות
  • ב-Details אפשר לראות עמודת CPU לכל Thread עמודת ה-CPU שם היא לכל תהליך. פירוט לפי Thread דורש Process Explorer או Performance Monitor.
  • התהליך מדווח רק על מה שה-Thread הראשי עושה העומס של תהליך הוא סכום כל ה-Threads שלו.
  • את מספר ה-Threads של תוכנה רואים ב-Startup או ב-Services מספר לכל תהליך מופיע רק בעמודה Threads של Details.
בדקו את עצמכם
תהליך תופס 25% CPU, ואתם רוצים לדעת איזה מה-Threads שלו אחראי. האם Task Manager מספיק?

לא. צריך כלי שמפרט לפי Thread, כמו Process Explorer (לשונית Threads בחלון המאפיינים).

במחשב עם 8 ליבות, שלושה Threads של אותו תהליך מחשבים בלי הפסקה. כמה CPU יראה התהליך, בערך?

כ-37.5%, שלוש ליבות מלאות מתוך שמונה, וכולן רשומות על התהליך.

חזרה לתוכן העניינים

Page File: זיכרון וירטואלי שיושב על הדיסק

מה תפקיד ה-Page File ואילו דפים מגיעים אליו

Windows אינה מנהלת את הזיכרון בית אחר בית, אלא בגושים בגודל קבוע שנקראים דפים (pages). במחשב רגיל דף הוא 4 KB. כל עוד יש מספיק RAM, כל הדפים שהתהליכים משתמשים בהם יושבים בו.

הבעיה מתחילה כשהתוכנות הפתוחות דורשות יחד יותר דפים ממה שה-RAM מכיל. כדי שלא ייכשלו, Windows צריכה מקום חלופי, ולשם כך שמור קובץ מיוחד בדיסק: ה-Page File.

תכונהמה לדעת
שם ומיקוםpagefile.sys בשורש כונן המערכת. כברירת מחדל זה C:\pagefile.sys
נראותמסומן כקובץ מערכת נסתר. ב-File Explorer הוא מופיע רק אחרי שמבקשים להציג גם קבצי מערכת מוגנים
נעילהWindows מחזיקה אותו פתוח מהעלייה ועד הכיבוי, ולכן ניסיון למחוק אותו כשהמערכת רצה נכשל

את ההסתרה רואים גם בשורת הפקודה. dir רגיל לא מוצא את הקובץ:

Text
dir C:\pagefile.sys
פלט
 Volume in drive C has no label.
 Volume Serial Number is 26FC-0E68

 Directory of C:\

File Not Found

רק עם המתג /a, שמבקש להציג כל קובץ בלי קשר לתכונות שלו, הוא מופיע. במחשב שעליו הורצו הדוגמאות של הפרק הוא תופס כ-33.5 GB:

Text
dir /a C:\pagefile.sys
פלט
 Volume in drive C has no label.
 Volume Serial Number is 26FC-0E68

 Directory of C:\

11/07/2026  03:40 PM    36,025,589,760 pagefile.sys
               1 File(s) 36,025,589,760 bytes
               0 Dir(s)  65,913,610,240 bytes free

כך נראה המחזור של דף שנשלח לדיסק וחוזר:

  1. ה-RAM מתקרב לקצה, ו-Windows מחפשת דפים שאפשר לפנות.
  2. המועמדים הם דפים של זיכרון פרטי שהתהליך כבר כתב בהם, ושאיש לא נגע בהם בזמן האחרון.
  3. התוכן שלהם מועתק ל-Page File, והמקום שלהם ב-RAM מתפנה לטובת מי שצריך אותו עכשיו.
  4. אם התהליך פונה שוב לכתובת שהדף שלה בחוץ, נוצר page fault. Windows מביאה את הדף מה-Page File חזרה ל-RAM, והתהליך ממשיך בלי לדעת שהדף נעדר.

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

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

מה יש בדףמגיע ל-Page File?הסיבה
משתנים, אובייקטים ומבנים שהתוכנה יצרה וכתבה בהם (heap, stack)כןהתוכן נוצר בזמן הריצה ואינו כתוב בשום קובץ, ולכן ה-Page File הוא המקום היחיד שיכול לשמור אותו
הוראות מכונה מקובץ exe או dllלאהקובץ שממנו נטענו עדיין בדיסק. Windows מוותרת על הדף, ובפעם הבאה קוראת אותו שוב מה-exe או מה-dll
קובץ נתונים שמופה לזיכרון ולא שונהלאהתוכן זהה למה שכתוב בקובץ הנתונים עצמו, ומשם הוא ייקרא שוב כשיידרש

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

מה מייחסים לומה נכון
תמונה מלאה של ה-RAM שנכתבת בכל כיבוישמירת כל הזיכרון בכיבוי שייכת למצב שינה (hibernation), והוא משתמש בקובץ אחר: hiberfil.sys
מקום שבו נשמרות תוכנות מותקנותתוכנות מותקנות יושבות בתיקיות רגילות. ה-Page File מחזיק רק דפי זיכרון של תהליכים שרצים
אזור לקבצים הזמניים של תוכנותלקבצים זמניים יש תיקיות Temp. ה-Page File שייך למנהל הזיכרון בלבד
מטמון שמזרז פתיחה חוזרת של קבציםהוא לא שומר עותקים של קבצים שנפתחו לאחרונה
תוספת של RAM פיזיהוא מגדיל את כמות הזיכרון שמותר להקצות, אבל במהירות של דיסק
טעויות נפוצות
  • כשחסר RAM, Windows שומרת ב-Page File גם את דפי הקוד של התוכנות, כדי שיהיה מאיפה לטעון אותם שוב. לקוד כבר יש מקור בדיסק: קובץ ה-exe או ה-dll. הדף משוחרר ונקרא מחדש משם.
  • דף של קובץ ממופה שהתוכן שלו לא השתנה חייב לעבור ל-Page File, אחרת הוא יאבד. הקובץ הממופה עצמו הוא העותק. כל עוד הדף לא שונה, אין מה לשמור.
  • תוכנות יכולות להשתמש ב-Page File כמקום לקבצים זמניים. ל-Page File אין שימוש מלבד גיבוי דפי זיכרון. קבצים זמניים הולכים לתיקיות Temp.
בדקו את עצמכם
תוכנת עריכת וידאו מחזיקה בזיכרון פריימים שפענחה ועיבדה, וגם את הקוד של codec.dll. ה-RAM מתמלא. מה מהשניים עשוי לעבור ל-Page File?

רק הפריימים, כי הם זיכרון פרטי שנוצר ושונה בזמן הריצה. דפי הקוד של codec.dll ישוחררו וייקראו שוב מהקובץ כשיהיה בהם צורך.

למה dir C:\pagefile.sys מדווח שהקובץ לא נמצא, למרות שהוא קיים?

כי זה קובץ מערכת נסתר, ו-dir מציג אותו רק עם המתג /a.

חזרה לתוכן העניינים

Working Set, Commit Charge ו-Commit Limit

כשתוכנה מבקשת זיכרון פרטי, למשל כש-malloc מגדיל את ה-heap, Windows לא חייבת לתת לה מיד דף ב-RAM. מה שהיא כן עושה הוא להתחייב (commit): לשריין לזיכרון הזה מקום מובטח, ב-RAM או ב-Page File. מכאן שלושה מספרים שקל לערבב.

המדדמה הוא סופראיפה מוצאים אותו ב-Task Manager
Working Setאת דפי התהליך שנמצאים ברגע זה ב-RAMעמודת Memory בלשוניות Processes ו-Details מציגה רק את החלק הפרטי שלו. את הערך המלא מוסיפים כעמודה בלשונית Details, דרך Select columns
Commit Chargeאת כל הזיכרון הפרטי שהוקצה ושההתחייבות עליו בתוקף, כולל דפים שיושבים כרגע ב-Page Fileלתהליך אחד: עמודת Commit size בלשונית Details. לכל המערכת: המספר שלפני הלוכסן בשורה Committed בלשונית Performance
Commit Limitאת התקרה של סך ההתחייבויות במערכת: סכום של RAM ו-Page Fileהמספר שאחרי הלוכסן בשורה Committed בלשונית Performance

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

C
#include <windows.h>
#include <psapi.h>
#include <stdio.h>

int main(void) {
    PERFORMANCE_INFORMATION pi = { sizeof(pi) };
    GetPerformanceInfo(&pi, sizeof(pi));
    double page_mb = pi.PageSize / (1024.0 * 1024.0);
    printf("Physical RAM : %8.0f MB\n", pi.PhysicalTotal * page_mb);
    printf("Commit total : %8.0f MB\n", pi.CommitTotal * page_mb);
    printf("Commit limit : %8.0f MB\n", pi.CommitLimit * page_mb);
    printf("Page size    : %8lu bytes\n", (unsigned long)pi.PageSize);
    return 0;
}
פלט
Physical RAM :    16023 MB
Commit total :    42405 MB
Commit limit :    50380 MB
Page size    :     4096 bytes

ואת הנפח של ה-Page File עצמו מדווחת המחלקה Win32_PageFileUsage (בפקודת PowerShell של קריאה בלבד), במגה-בייטים:

Text
Get-CimInstance Win32_PageFileUsage | Select-Object Name,AllocatedBaseSize,CurrentUsage | Format-List
פלט
Name              : C:\pagefile.sys
AllocatedBaseSize : 34356
CurrentUsage      : 9258

חברו את המספרים: 16,023 MB של RAM ועוד 34,356 MB של Page File נותנים 50,379, כמעט בדיוק ה-Commit limit שהודפס. ה-Commit total, יותר מ-42,000 MB, גדול בהרבה מכל ה-RAM, ובכל זאת שום דבר לא נכשל: ההבטחות מגובות גם בדיסק, וחלק מהן עוד לא נכתבו אף פעם.

אותו היגיון בקנה מידה של תהליך אחד: Commit size שגבוה מ-Memory אינו תקלה. חלק ממה שהוקצה לתהליך יושב ב-Page File, וחלק אולי עוד לא נגעו בו.

אם ה-Commit total במחשב הזה יגיע ל-50,380 MBמה יקרה
בקשה נוספת לזיכרון פרטיתידחה. Windows לא מבטיחה מעבר לתקרה
התוכנה שביקשהתקבל שגיאת חוסר זיכרון, תציג הודעה או תיפול. ייתכן שגם Windows תתריע שהזיכרון במערכת נמוך
ה-RAMיכול להיות רחוק מלהתמלא, כי התקרה סופרת הבטחות ולא דפים שיושבים ב-RAM
התקרה עצמהתמיד RAM ועוד הגודל הנוכחי של ה-Page File, לא יותר. Windows גם לא תמחק קבצים כדי להרחיב אותה
אף אחד משלושת המונחים לא סופר Threads, ליבות או קבצים. Commit Limit לא קובע כמה Threads ירוצו, כמה ליבות יקבל תהליך או בכמה כוננים יהיה Page File. ו-Commit Charge אינו הזיכרון הפנוי אלא ההפך שלו: מה שכבר נתפס.
תרחיש 9: קריאת השורה Committed בלשונית Performance

תחנת עבודה עם 12 GB RAM ו-Page File קבוע של 6 GB. תחת Memory בלשונית Performance מופיעים הנתונים האלה:

שדהערך
In use4.1 GB
Available7.6 GB
Committed17.7/18.0 GB
  1. התקרה היא 12 ועוד 6, כלומר 18 GB, וזה המספר שאחרי הלוכסן.
  2. ההתחייבויות עומדות על 17.7 GB, צמוד לתקרה. הקצאה גדולה נוספת עלולה להידחות.
  3. ה-RAM רחוק מלהתמלא: In use מראה 4.1 GB בלבד.
  4. Committed לא אומר כמה מהקובץ בדיסק כבר מלא, ואין לו קשר לנתון Cached של המטמון.
  5. אם התקרה תיפרץ, Windows לא תתחיל לסגור תהליכים כדי לפנות מקום. הבקשות החדשות פשוט ייכשלו.
טעויות נפוצות
  • Committed שמתקרב לתקרה מעיד שה-RAM כמעט נגמר. על מצב ה-RAM מעיד In use. Committed משווה את סך ההקצאות לסכום של RAM ו-Page File.
  • Committed מראה כמה מתוך ה-Page File תפוס. הוא סופר את כל ההתחייבויות במערכת, בלי קשר למקום שבו יושבים הדפים כרגע.
  • Working Set הוא הנפח שה-Page File תופס בדיסק. Working Set הוא דפי התהליך שנמצאים עכשיו ב-RAM.
  • Commit Charge מראה כמה זיכרון עוד נשאר לתוכנות חדשות. ההפך: הוא מודד את מה שכבר הוקצה.
בדקו את עצמכם
לשרת יש 32 GB RAM, ול-Page File שלו הוגדרו 8 GB. מה ה-Commit Limit?

40 GB.

בלשונית Details, לתהליך יש Commit size של 3 GB, אבל Memory מראה רק 900 MB. איפה שאר הזיכרון?

חלקו הועבר ל-Page File, וחלקו אולי הוקצה ועוד לא נכתב, ולכן אינו תופס דפים ב-RAM.

חזרה לתוכן העניינים

זיכרון הליבה: Paged Pool מול Non-Paged Pool

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

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

אזוריכול לעבור ל-Page File?ההיגיון
Paged Poolכןנתונים שניגשים אליהם רק ברגעים שבהם מותר להמתין. כשחסר RAM, דפים ממנו שלא נגעו בהם לאחרונה נכתבים ל-Page File, ונקראים בחזרה כשצריך אותם
Non-Paged Poolלא, הוא נשאר ב-RAM תמידנתונים שהליבה או דרייבר צריכים גם במצבים שבהם אסור לעצור ולחכות לדיסק, למשל באמצע טיפול בפסיקה של חומרה

את גודל שני המאגרים מראה עמוד Memory בלשונית Performance. ולזכירה: Paged הוא מה שמותר להחליף לדיסק, והתחילית Non מבטלת את ההיתר.

טעויות נפוצות
  • Non-Paged Pool הוא האזור שנשלח לדיסק, ו-Paged Pool נשאר קבוע ב-RAM. הפוך. Paged Pool הוא האזור שמותר להעביר.
  • Paged Pool הוא זיכרון של תוכנות המשתמש, ו-Non-Paged Pool של הליבה. שני האזורים הם זיכרון ליבה. ההבדל ביניהם הוא רק אם מותר להוציא אותם לדיסק.
  • שני האזורים עוברים לדיסק, ורק הגודל המרבי שלהם שונה. רק Paged Pool עובר. Non-Paged Pool לעולם לא.
בדקו את עצמכם
דרייבר של מקלדת USB מעדכן מבנה נתונים בזמן שהוא מטפל בפסיקה, ואסור לו לחכות שם לדיסק. איפה המבנה צריך לשבת?

ב-Non-Paged Pool, כי רק שם מובטח שהוא יהיה ב-RAM ברגע הפסיקה.

רשומה של הליבה נקראת לעתים רחוקות, ותמיד ברגעים שבהם מותר להמתין. באיזה אזור אפשר לשמור אותה כדי לא לתפוס RAM לשווא?

ב-Paged Pool.

חזרה לתוכן העניינים

קביעת הגודל והמיקום של ה-Page File

יש מקום אחד שבו קובעים את ה-Page File: חלון System Properties. כך מגיעים להגדרה:

  1. מקישים Win+R, כותבים sysdm.cpl ומאשרים. נפתח System Properties.
  2. בלשונית Advanced, במסגרת Performance, לוחצים על Settings.
  3. נפתח Performance Options. עוברים גם בו ללשונית Advanced, ובמסגרת Virtual memory לוחצים על Change.
  4. מורידים את הסימון מ-Automatically manage paging file size for all drives. בלי זה שאר האפשרויות נעולות.
  5. מסמנים כונן ברשימה, בוחרים Custom size, ממלאים Initial size ו-Maximum size במגה-בייטים ולוחצים Set.
  6. רוצים Page File גם בכונן נוסף? מסמנים אותו וחוזרים על השלב הקודם. כל כונן מקבל גודל משלו.

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

מקום שמחפשים בו בטעותמה יש שם באמת
BIOSהגדרות חומרה ואתחול. ה-Page File הוא עניין של מערכת ההפעלה, וה-BIOS לא יודע עליו דבר
Task Managerתצוגה בלבד: מראה את נתוני הזיכרון ולא משנה אותם
Disk Managementניהול דיסקים, מחיצות ואותיות כונן
Properties של pagefile.sys ב-File Explorerמאפיינים של קובץ רגיל, בלי שום הגדרה של זיכרון וירטואלי

הבחירה החשובה בחלון הזה היא בין גודל שהמערכת מנהלת לגודל ידני:

System managed size (ברירת המחדל)Custom size (ידני)
מי קובעWindows: גודל התחלתי, ואחר כך הגדלה לפי הלחץ על הזיכרוןאתם: Initial size ו-Maximum size
מתי הגודל משתנהגם באמצע העבודה, בלי אתחולרק כשמשנים את ההגדרה
עד כמהעד תקרה שהמערכת מציבה, ולא עד שהכונן מתמלאעד ה-Maximum size שקבעתם
מה זה עושה ל-Commit Limitהתקרה מתרחבת יחד עם הקובץ בדיוק כשהעומס עולה, ולכן שגיאות חוסר זיכרון נדירות יותרקבועה, ובעומס חריג עלולה להיגמר
מתי מתאיםכמעט תמידצורך מיוחד: מעט מקום בכונן, או Crash Dump שדורש גודל מסוים (בהמשך)

במחשב של הדוגמאות הגודל מנוהל בידי המערכת, וזה ניכר במדידות. פלט ה-dir /a שהוצג למעלה הראה 36,025,589,760 בתים, כלומר 34,356 MB. אותה פקודה, שהורצה כרבע שעה קודם לכן, הראתה 33,825,505,280 בתים (32,258 MB): הקובץ גדל ביותר מ-2 GB באמצע העבודה, בלי אתחול.

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

בחירהמה היא נותנתמה היא לא נותנת
Page File על SSD מהירהחלפת דפים קצרה יותר, ולכן תגובה טובה יותר תחת עומס זיכרוןלא מקטינה את הגודל הנדרש, ולא הופכת את הקובץ ל-RAM: גם SSD איטי בהרבה מזיכרון
Page File על כונן חיצוני איטישום יתרון בביצועיםרק מאריכה כל החלפה
ביטול ה-Page File לגמרימקום פנוי בכונןה-Commit Limit יורד לגודל ה-RAM בלבד, והסיכון לשגיאות חוסר זיכרון עולה
תרחיש 10: שני כוננים, שני קבצים

במחשב יש כונן C מסוג NVMe SSD וכונן E מסוג HDD ישן. עד היום הגודל היה מנוהל בידי המערכת, וב-C ישב קובץ של 12 GB. מנהלת הרשת רוצה במקומו Page File קבוע של 6 GB ב-C ועוד 2 GB ב-E.

  1. sysdm.cpl, לשונית Advanced, כפתור Settings תחת Performance, שוב לשונית Advanced, ו-Change תחת Virtual memory.
  2. מבטלת את הניהול האוטומטי לכל הכוננים.
  3. מסמנת את C, בוחרת Custom size, כותבת 6144 בשני השדות ולוחצת Set.
  4. מסמנת את E, כותבת 2048 בשני השדות, Set, ואז OK. הקובץ ב-C ירד מ-12 GB ל-6 GB, ולכן Windows מודיעה שנדרשת הפעלה מחדש. אחריה שני הקבצים בתוקף.

אחרי ההפעלה מחדש ה-Commit Limit הוא ה-RAM ועוד 8 GB, הסכום של שני הקבצים. אם מה שמעניין אותה הוא תגובה מהירה תחת עומס, עדיף לתת את רוב הגודל לקובץ שעל ה-SSD.

טעויות נפוצות
  • את הנפח של ה-Page File מגדירים ב-Task Manager, בעמוד Memory. שם רק קוראים את הנתונים. ההגדרה נמצאת ב-System Properties, תחת Virtual memory.
  • גודל שהמערכת מנהלת יגדל עד שלא יישאר מקום פנוי בכונן. למערכת יש תקרה משלה לגודל הזה.
  • Windows משנה גודל אוטומטי רק כשהמחשב עולה. היא מגדילה אותו גם באמצע העבודה, כשהעומס דורש.
  • Page File הוא בעצם RAM פיזי נוסף. הוא מרחיב את התקרה של מה שמותר להקצות, לא את הזיכרון הפיזי.
  • על SSD מספיק Page File קטן יותר. המהירות לא משנה את הגודל הנדרש, רק את זמן הגישה.
בדקו את עצמכם
מה מקלידים בחלון Run כדי לפתוח ישר את System Properties?

sysdm.cpl.

הקטנתם את ה-Page File מ-8 GB ל-4 GB ולחצתם OK. מתי השינוי יחול?

רק אחרי הפעלה מחדש. הגדלה, לעומת זאת, פועלת מיד.

חזרה לתוכן העניינים

שתי תקלות שונות: Page File קטן מדי ו-Thrashing

שתי התקלות קשורות לזיכרון ושתיהן מתסכלות, אבל הסיבה, הסימנים והתיקון שונים לגמרי. מבדילים ביניהן לפי מה שמראה לשונית Performance.

Page File קטן מדיThrashing
מה חסרמקום להתחייבויות: ה-Commit Limit נמוך מדיRAM: הוא קטן מקבוצת העבודה (working set), כלומר מסך הדפים שהתוכנות הפעילות צריכות באותו פרק זמן
מה רואיםCommitted צמוד לתקרה, הקצאות נדחות, הודעות על חוסר זיכרון ותוכנות שנופלות, ולפעמים יש RAM פנויWindows מוציאה ומחזירה דפים בלי הפסקה: הדיסק עובד כל הזמן ונורית הדיסק דולקת, הכול איטי מאוד, וה-CPU כמעט בטל כי הוא מחכה לנתונים
מה עוזרלהגדיל את ה-Page File, או להחזיר אותו לניהול של Windowsלהוסיף RAM, או לסגור חלק מהתוכנות שרצות יחד
מה לא עוזרלהקטין את הקובץ עוד יותר, או לחכות ש-Windows תסגור תהליכים בעצמה או שהמעבד יעבור לחיסכון בחשמל. היא לא עושה אף אחד מאלה; היא פשוט דוחה הקצאותלהגדיל את ה-Page File. הקובץ הוא רק הזירה של ההחלפות ולא הסיבה, וקובץ גדול לא יוצר החלפות

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

תרחיש 11: מחשב נייד ישן תחת עומס

נייד עם 4 GB RAM. פתוחים בו עורך וידאו, שני גיליונות אלקטרוניים גדולים ודפדפן עם 25 לשוניות. לשונית Performance מראה Disk 99%, CPU 6%, Memory 95%.

  • דיסק עמוס, מעבד כמעט בטל, RAM כמעט מלא: זו התמונה של Thrashing.
  • התוכנות הפעילות צריכות יותר דפים ממה שנכנס ב-4 GB, ולכן Windows מחליפה דפים מול ה-Page File ללא הפסקה.
  • הגדלת ה-Page File לא תשנה את התחושה. סגירת עורך הווידאו או חלק מהלשוניות, או שדרוג ה-RAM, כן.
טעויות נפוצות
  • דיסק עמוס יחד עם מעבד רגוע מעיד על Page File שהוגדר גדול מדי. גודל הקובץ לא יוצר החלפות. החלפות נוצרות כשה-RAM לא מספיק.
  • כשהדיסק לא מפסיק לעבוד, האשם הוא כנראה דרייבר תקול או שירות שכותב ל-Registry. דיסק עמוס יחד עם RAM מלא והרבה תוכנות פתוחות מצביע על מחסור בזיכרון.
בדקו את עצמכם
תוכנת חישוב נופלת עם הודעת out of memory. לשונית Performance מראה In use של 6 GB מתוך 32 GB RAM, ו-Committed של 35.7/36.0 GB. מה התקלה?

התקרה נוצלה עד הסוף. ה-Page File הוא רק 4 GB, ולכן הקצאות נדחות אף שרוב ה-RAM פנוי. צריך להגדיל אותו או להחזיר אותו לניהול של Windows.

חזרה לתוכן העניינים

Crash Dump: ה-Page File בזמן מסך כחול

מה מסך כחול צריך מה-Page File? כדי שאפשר יהיה לחקור קריסה, Windows שומרת ברגע הקריסה את תוכן הזיכרון לקובץ שנקרא dump. הקושי הוא שבאותו רגע אי אפשר לסמוך על מערכת הקבצים, ולכן הכתיבה נעשית לשטח שכבר מוקצה בדיסק.

רגעאיפה ה-dumpמה עושה ה-Page File
המסך הכחולנכתב לתוך ה-Page File שבכונן שבו מותקנת Windowsמשמש מחסן זמני ל-dump
ההפעלה הבאהמועתק לקובץ %SystemRoot%\MEMORY.DMP, בדרך כלל C:\Windows\MEMORY.DMPמתפנה
מכאן והלאהב-MEMORY.DMPחוזר להיות זיכרון וירטואלי רגיל
סוג ה-dumpמה נשמרמה נדרש מה-Page File
Complete memory dumpכל ה-RAMגודל קרוב לגודל ה-RAM, בכונן שבו מותקנת Windows
Small memory dumpמידע מצומצם על הקריסהקובץ קטן בהרבה מספיק
כל סוג, כשמוגדר dump file ייעודילפי הסוגה-dump נכתב לקובץ הייעודי, ולכן הדרישה הזו מה-Page File נופלת
תרחיש 12: שרת שלא ישמור את ה-dump

בשרת 64 GB RAM. ההגדרה היא Complete memory dump, בלי dump file ייעודי. ה-Page File קבוע על 8 GB, ונמצא רק בכונן הנתונים E.

  • בכונן C, שבו מותקנת Windows, אין Page File בכלל, ולכן ברגע הקריסה אין לאן לכתוב את ה-dump.
  • וגם אילו הקובץ היה ב-C, 8 GB לא מכילים תוכן של 64 GB.
  • התיקון: Page File של כ-64 GB בכונן C.
טעויות נפוצות
  • ה-dump נכתב ישר ל-MEMORY.DMP, אז אין סיבה ל-Page File גדול. בזמן הקריסה הוא נכתב קודם ל-Page File, ורק באתחול הבא מועתק ל-MEMORY.DMP.
  • עדיף שה-Page File יישב בכונן נתונים נפרד, שם קריסה לא תגיע אליו. בשביל ה-dump הוא צריך להיות דווקא בכונן של Windows.
  • אחרי הקריסה ה-dump נשאר בתוך ה-Page File. באתחול הבא הוא יוצא החוצה לקובץ MEMORY.DMP.
בדקו את עצמכם
אחרי מסך כחול והפעלה מחדש, באיזה קובץ מחפשים את ה-dump המלא?

%SystemRoot%\MEMORY.DMP, שבדרך כלל הוא C:\Windows\MEMORY.DMP.

בתחנה עם 16 GB RAM מוגדר Small memory dump. האם צריך בשבילו Page File של 16 GB?

לא. ל-dump קטן מספיק Page File קטן בהרבה.

חזרה לתוכן העניינים

נתונים רגישים ב-Page File וניקוי בכיבוי

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

הנעילה שמגנה על הקובץ קיימת רק כל עוד ה-Windows שלו רצה. מי שמוצא את המחשב יכול לחבר את הדיסק כדיסק נוסף למערכת אחרת ולקרוא את הקובץ כמו כל קובץ.

פרטים
ההגדרה שפותרת את זהShutdown: Clear virtual memory pagefile
איפהLocal Security Policy, ובתוכו Local Policies ואז Security Options
מה היא עושהבכל כיבוי מסודר Windows כותבת על כל תוכן הקובץ
מה זה עולהכיבוי ארוך יותר
מה היא לא עושהלא משפרת ביצועים, כי היא פועלת רק ברגע הכיבוי

המדיניות נשמרת בערך Registry, ואפשר לבדוק את מצבה בקריאה בלבד. במחשב הזה הערך 0, כלומר הניקוי כבוי:

Text
reg query "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management" /v ClearPageFileAtShutdown
פלט
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management
    ClearPageFileAtShutdown    REG_DWORD    0x0
רעיוןלמה הוא לא פותר
להעביר את הקובץ לכונן אחרהנתונים עדיין נכתבים לדיסק, פשוט לכונן אחר באותו מחשב
להגדיל את הקובץקובץ גדול יותר לא מוחק את מה שכבר כתוב בו
למחוק את pagefile.sys בעצמכםWindows מחזיקה אותו פתוח וחוסמת מחיקה כל זמן שהיא רצה
טעויות נפוצות
  • ניקוי בכיבוי מפחית את הכתיבה ל-Page File במהלך העבודה. הניקוי פועל רק ברגע הכיבוי, ולא משנה דבר במהלך היום.
  • Page File בגודל כפול מה-RAM ידרוס עם הזמן את הנתונים הרגישים. שום דבר לא מבטיח דריסה כזו. רק המדיניות מנקה בוודאות.
בדקו את עצמכם
איש IT רוצה למחוק את pagefile.sys לפני שהמחשב עובר לעובד אחר, כש-Windows פועלת. למה הניסיון ייכשל?

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

איזו הגדרה דואגת שאחרי כיבוי מסודר לא יישאר תוכן קריא ב-Page File?

הפעלה של Shutdown: Clear virtual memory pagefile בחלון Local Security Policy.

חזרה לתוכן העניינים

Handle: הידית שדרכה תהליך פונה לאובייקט ליבה

מהו Handle

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

בהשאלה ל-Windows: המעיל הוא אובייקט ליבה, כמו קובץ פתוח, מפתח Registry, תהליך, Thread, Mutex או Event. המלתחה היא הליבה, ותוכנה שרצה ב-user mode היא המבקרת, שלא נכנסת למחסן בעצמה.

הדסקית היא ה-Handle. התוכנה מקבלת אותה כשהיא קוראת, למשל, ל-CreateFile, ומגישה אותה בכל בקשה הבאה: ReadFile, WriteFile וכן הלאה. המספר אטום (opaque), כלומר אין לתוכנה מה לחשב או לפרש בו.

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

Text
Handle table of backup_agent.exe (PID 6208)
  value   type     target                          access
  0x0A8   Event    (unnamed)                       SYNCHRONIZE
  0x1F0   File     D:\exports\clients.csv          READ
  0x214   Key      HKLM\SOFTWARE\BackupAgent       QUERY_VALUE
  0x2C4   Thread   TID 9140                        ALL_ACCESS

קל לבלבל Handle עם מושגים אחרים, ולכן כדאי לראות במה הוא שונה מכל אחד מהם:

מושג שמתבלבלים איתוההבדל
מזהה גלובלי של האובייקטאותו ערך בתהליך אחר לא מוביל לאותו אובייקט
PIDPID מזהה תהליך שלם, ו-Handle מזהה אובייקט אחד בטבלה של תהליך. לתהליך יחיד יכולים להיות אלפי Handles
מצביע (pointer) לזיכרוןHandle לא מכיל כתובת של המשאב, לא פיזית ולא וירטואלית. רק הליבה מתרגמת אותו לאובייקט
מספר קבועהערך חי כל עוד ה-Handle פתוח באותו תהליך. בהרצה הבאה, ובוודאי אחרי אתחול של המחשב, אותו מספר לא שווה דבר
טעויות נפוצות
  • ה-Handle מחזיק את הכתובת הפיזית של הקובץ בזיכרון. הוא ערך אטום, והליבה היא שממפה אותו לאובייקט.
  • Handle ו-PID הם שני שמות לאותו מספר. PID מזהה תהליך. Handle מזהה אובייקט מסוים בתוך טבלת ה-Handles של תהליך.
  • אפשר לשמור ערך של Handle ולהשתמש בו בהרצה הבאה. Handle תקף רק כל עוד הוא פתוח בתהליך שקיבל אותו.
בדקו את עצמכם
שירות כתב את ערך ה-Handle של קובץ הלוג שלו לקובץ JSON. אחרי אתחול של המחשב הוא קרא את הערך והשתמש בו. מה יקרה?

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

חזרה לתוכן העניינים

פתיחה, שימוש וסגירה

כל Handle נפתח, משמש ונסגר. נעבור על שלושת השלבים בעזרת התוכניות שבפרק.

פתיחה. קובץ נפתח ב-CreateFile, Thread נולד ב-CreateThread, Mutex ב-CreateMutex, ומפתח Registry נפתח ב-RegOpenKeyEx. בין שהאובייקט חדש ובין שהוא כבר קיים, בסוף הקריאה התהליך מקבל Handle, בתנאי שעבר את בדיקת ההרשאות:

מי בבדיקהמה התפקיד שלו
Access Token של התהליךמביא את זהות המשתמש ואת הקבוצות שלו, כפי שנקבעו כשהתחבר
ACL של האובייקטמביא את רשימת ההרשאות: מי רשאי לעשות מה באובייקט
Security Reference Monitor, רכיב בליבהמשווה בין השניים. אם הגישה שהתבקשה מותרת, נוצרת רשומה בטבלה, ואם לא, הבקשה נדחית
מי לא משתתףאנטי-וירוס, סיומת הקובץ ושם ה-exe של המבקש

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

פונקציותבהצלחהבכישלון
CreateFileHandle תקףINVALID_HANDLE_VALUE, שערכו -1 ולא 0
רוב פונקציות ה-Create האחרות: CreateThread, CreateMutex, CreateEventHandle תקףNULL, כלומר 0

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

התוכנית הבאה מכשילה בכוונה שתי פתיחות: קובץ בתיקייה שלא קיימת, ו-Mutex בשם שכבר תפוס בידי Event:

C
#include <windows.h>
#include <stdio.h>

int main(void) {
    /* 1) CreateFile on a path that does not exist */
    HANDLE f = CreateFileW(L"C:\\no_such_folder\\budget.xlsx", GENERIC_READ,
                           FILE_SHARE_READ, NULL, OPEN_EXISTING,
                           FILE_ATTRIBUTE_NORMAL, NULL);
    DWORD e1 = GetLastError();              /* read it right away */
    printf("CreateFileW : value=%lld  NULL? %s  INVALID_HANDLE_VALUE? %s  error=%lu\n",
           (long long)(INT_PTR)f, f == NULL ? "yes" : "no",
           f == INVALID_HANDLE_VALUE ? "yes" : "no", e1);

    /* 2) CreateMutexW with a name already taken by an Event */
    HANDLE ev = CreateEventW(NULL, TRUE, FALSE, L"Local\\orders_ready");
    HANDLE mx = CreateMutexW(NULL, FALSE, L"Local\\orders_ready");
    DWORD e2 = GetLastError();
    printf("CreateMutexW: value=%lld  NULL? %s  error=%lu\n",
           (long long)(INT_PTR)mx, mx == NULL ? "yes" : "no", e2);

    CloseHandle(ev);
    return 0;
}
פלט
CreateFileW : value=-1  NULL? no  INVALID_HANDLE_VALUE? yes  error=3
CreateMutexW: value=0  NULL? yes  error=6

CreateFileW החזירה -1 ולא NULL, עם קוד 3 (ERROR_PATH_NOT_FOUND). CreateMutexW החזירה NULL, עם קוד 6 (ERROR_INVALID_HANDLE), כי השם כבר שייך לאובייקט מסוג אחר. בדיקה של h == NULL אחרי CreateFile הייתה מפספסת את הכישלון הראשון לגמרי.

שימוש. בכל פעולה על האובייקט התהליך מעביר את ה-Handle כפרמטר: ReadFile(h, ...), WaitForSingleObject(h, ...) וכן הלאה.

סגירה. הפונקציה הכללית היא CloseHandle, ולשני סוגים יש סוגרת משלהם: מפתח Registry נסגר ב-RegCloseKey, וזו שתחזיר את המונה לבסיס בתוכנית הדליפה שבהמשך, ו-Handle של חיפוש קבצים נסגר ב-FindClose.

מה בדיוק נסגר? הרשומה בטבלה, ולא בהכרח האובייקט. בתוכנית השכפול שבחלק הבא קובץ ממשיך לחיות אחרי CloseHandle על אחד משני ה-Handles שלו, והליבה משחררת אותו רק כשנעלמת הרשומה האחרונה שמפנה אליו.

ומה אם תוכנה לא סוגרת בעצמה?

  • תוכנה שיוצאת בצורה מסודרת סוגרת את ה-Handles שלה לפני היציאה, והמשאבים חוזרים למערכת.
  • תהליך שנגמר בכל דרך אחרת, גם אם סיימו אותו בכוח, לא משאיר שאריות: Windows סוגרת בשבילו כל מה שנשאר בטבלה.
  • בשני המקרים אף קובץ לא נמחק מהדיסק וה-Page File לא משתנה. סגירה משחררת גישה, לא נתונים.
טעויות נפוצות
  • אחרי CreateFile מספיק לבדוק אם התוצאה היא NULL. CreateFile נכשלת עם INVALID_HANDLE_VALUE, כלומר -1. NULL מסמן כישלון אצל רוב פונקציות ה-Create האחרות, לא אצל CreateFile.
  • Windows Defender הוא שמחליט אם תהליך יקבל Handle. את ההרשאה בודק Security Reference Monitor בליבה, לפי ה-Access Token מול ה-ACL.
  • כשתוכנה נסגרת כראוי, Windows מוחקת את הקבצים שהיא יצרה, או פותחת Handles חדשים במקום הישנים. הסגירה רק מפנה את המשאבים. הקבצים נשארים, ואף Handle לא נוצר מחדש.
בדקו את עצמכם
מפתח כתב if (h == NULL) return; מיד אחרי CreateFile, והקובץ שביקש לא קיים. מה תעשה התוכנית?

הבדיקה לא תתפוס את הכישלון, כי הוחזר -1 ולא 0. התוכנית תמשיך עם Handle לא תקף, וכל ReadFile עליו ייכשל.

CreateEvent החזירה NULL. מה הצעד הבא?

לקרוא מיד ל-GetLastError ולברר את הסיבה, למשל 5 לחוסר הרשאה.

חזרה לתוכן העניינים

כל Handle שייך לטבלה של תהליך אחד

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

בתוך תהליך אחד, לעומת זאת, כל ה-Threads עובדים מול אותה טבלה, ולכן Handle שפתח Thread אחד תקף גם לכל השאר.

יש רק שתי דרכים מכוונות לתת לתהליך אחר גישה לאותו אובייקט, ו-Windows לא עושה אף אחת מהן מעצמה:

דרךמה קורה
שכפול: DuplicateHandleהפונקציה מוסיפה לטבלה של תהליך היעד רשומה חדשה שמפנה לאותו אובייקט. את הערך החדש צריך אחר כך למסור לתהליך היעד בדרך כלשהי
ירושה (inheritance)תהליך יוצר תהליך בן ומבקש ירושת Handles. הבן מקבל בטבלה שלו עותק של כל ה-Handles שסומנו כניתנים לירושה, וכל עותק מפנה לאותו אובייקט

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

C
#include <windows.h>
#include <stdio.h>

static void where(HANDLE h, const char *label) {
    wchar_t path[MAX_PATH];
    DWORD n = GetFinalPathNameByHandleW(h, path, MAX_PATH, FILE_NAME_NORMALIZED);
    if (n) printf("%-10s value=0x%llX -> %ls\n", label, (unsigned long long)(ULONG_PTR)h, wcsrchr(path, L'\\') + 1);
    else   printf("%-10s value=0x%llX -> error %lu\n", label, (unsigned long long)(ULONG_PTR)h, GetLastError());
}

int main(void) {
    HANDLE a = CreateFileW(L"roster.csv", GENERIC_READ | GENERIC_WRITE, 0, NULL,
                           CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    HANDLE b = NULL;
    /* a second table entry for the same kernel object */
    DuplicateHandle(GetCurrentProcess(), a, GetCurrentProcess(), &b, 0, FALSE,
                    DUPLICATE_SAME_ACCESS);
    where(a, "original:");
    where(b, "duplicate:");

    CloseHandle(a);                       /* removes only the first entry */
    where(b, "dup after:");
    where(a, "closed:");                  /* the old value is no longer valid */

    CloseHandle(b);                       /* last handle: the object is freed */
    DeleteFileW(L"roster.csv");
    return 0;
}
פלט
original:  value=0x98 -> roster.csv
duplicate: value=0x9C -> roster.csv
dup after: value=0x9C -> roster.csv
closed:    value=0x98 -> error 6

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

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

תרחיש 13: אותו מספר בשני תהליכים
  1. התהליך payroll.exe (PID 7804) פותח את salaries.xlsx ומקבל את הערך 0x2C8.
  2. התהליך report.exe (PID 9112), של אותו משתמש, קורא ל-WriteFile עם 0x2C8.
  3. בטבלה של report.exe אין רשומה בערך הזה, והקריאה נכשלת בשגיאת Handle לא תקף.
  4. אילו report.exe החזיק במקרה 0x2C8 פתוח לקובץ הלוג שלו, הכתיבה הייתה הולכת לשם, ולא לגיליון של payroll.exe.
  5. כדי ש-report.exe יעבוד על הגיליון, אחת משתיים: payroll.exe משכפל אליו Handle ב-DuplicateHandle, או ש-report.exe פותח את הקובץ בעצמו ומקבל Handle משלו.
טעויות נפוצות
  • ערך של Handle מזהה את האובייקט בכל המערכת. הערך מקומי לטבלה של התהליך שקיבל אותו.
  • שני תהליכים של משתמש אחד עובדים מול אותה טבלת Handles. לכל תהליך טבלה נפרדת, בלי קשר למשתמש.
  • Windows מעבירה Handles בין תהליכים מעצמה כשצריך. זה קורה רק כשמבקשים במפורש: ירושה לתהליך בן, או DuplicateHandle.
בדקו את עצמכם
תהליך אב רוצה שתהליך בן שהוא מפעיל יכתוב לצינור (pipe) שהאב פתח, בלי שהבן יפתח אותו בעצמו. אילו דרכים יש לו?

ירושה: לסמן את ה-Handle כניתן לירושה וליצור את הבן עם ירושת Handles. האפשרות השנייה היא DuplicateHandle לטבלה של הבן.

בתהליך רצים שני Threads, ואחד מהם פתח Mutex. האם השני יכול להשתמש באותו ערך?

כן. כל ה-Threads של תהליך עובדים מול טבלה אחת.

חזרה לתוכן העניינים

מצב שיתוף, קבצים נעולים ו-Sharing Violation

מי שפותח קובץ ב-CreateFile מחליט, באותה קריאה, מה יוכלו לעשות בקובץ אחרים כל עוד ה-Handle שלו פתוח. זה מצב השיתוף (share mode), והוא מורכב מדגלים:

ערך share modeמה מותר לאחרים בזמן שה-Handle פתוח
0כלום: מי שפתח מחזיק בקובץ לבדו
FILE_SHARE_READלפתוח את הקובץ גם הם, לקריאה
FILE_SHARE_WRITEלפתוח אותו לכתיבה
FILE_SHARE_DELETEלמחוק אותו או לשנות את שמו

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

C
#include <windows.h>
#include <stdio.h>

static void try_delete(const wchar_t *name, const char *when) {
    BOOL ok = DeleteFileW(name);
    DWORD err = ok ? 0 : GetLastError();
    printf("%-28s DeleteFileW -> %s (error %lu)\n", when, ok ? "deleted" : "refused", err);
}

static void run(DWORD share, const char *label) {
    const wchar_t *name = L"invoice_042.log";
    printf("--- share mode: %s ---\n", label);
    HANDLE h = CreateFileW(name, GENERIC_WRITE, share, NULL, CREATE_ALWAYS,
                           FILE_ATTRIBUTE_NORMAL, NULL);

    /* a second opener asks for read access */
    HANDLE r = CreateFileW(name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                           NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    printf("%-28s open for read -> %s\n", "while writer handle open:",
           r == INVALID_HANDLE_VALUE ? "refused" : "ok");
    if (r != INVALID_HANDLE_VALUE) CloseHandle(r);

    try_delete(name, "while writer handle open:");
    CloseHandle(h);
    if (GetFileAttributesW(name) != INVALID_FILE_ATTRIBUTES)
        try_delete(name, "after CloseHandle:");
    else
        printf("%-28s file is gone\n", "after CloseHandle:");
}

int main(void) {
    run(FILE_SHARE_READ, "FILE_SHARE_READ");
    run(FILE_SHARE_READ | FILE_SHARE_DELETE, "FILE_SHARE_READ | FILE_SHARE_DELETE");
    return 0;
}
פלט
--- share mode: FILE_SHARE_READ ---
while writer handle open:    open for read -> ok
while writer handle open:    DeleteFileW -> refused (error 32)
after CloseHandle:           DeleteFileW -> deleted (error 0)
--- share mode: FILE_SHARE_READ | FILE_SHARE_DELETE ---
while writer handle open:    open for read -> ok
while writer handle open:    DeleteFileW -> deleted (error 0)
after CloseHandle:           file is gone

מה הפלט מלמד:

  • בלי FILE_SHARE_DELETE, ‏DeleteFileW נדחתה עם קוד 32, ERROR_SHARING_VIOLATION. הקובץ נשאר במקומו בלי שום שינוי.
  • אחרי CloseHandle אותה מחיקה עברה. אותו דבר יקרה כשהתהליך המחזיק מסתיים, כי אז Windows סוגרת את ה-Handle שלו.
  • בהרצה השנייה FILE_SHARE_DELETE היה חלק ממצב השיתוף, ולכן המחיקה התקבלה בזמן שה-Handle עוד היה פתוח.
  • הפתיחה לקריאה הצליחה בשתי ההרצות, כי FILE_SHARE_READ ניתן בשתיהן.

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

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

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

אז מה עושים? לא מאתחלים את המחשב, אלא מוצאים איזה תהליך מחזיק את הקובץ, וזה התפקיד של Process Explorer ו-Handle.exe שבסוף החלק, ומסיימים אותו, למשל מלשונית Details ב-Task Manager. ברגע שהוא יוצא, ה-Handle נסגר והקובץ משתחרר.

תרחיש 14: נגן שנסגר רק למראית עין
  1. רון סוגר את חלון נגן הווידאו ומנסה למחוק את lecture.mp4.
  2. File Explorer מודיע שהקובץ פתוח בתוכנה אחרת, ומציין את הנגן.
  3. בלשונית Details של Task Manager רון מוצא את mediaplayer.exe עדיין רץ, בלי שום חלון.
  4. הוא מסיים את התהליך. Windows סוגרת את כל ה-Handles שנשארו בטבלה שלו, והמחיקה עוברת.
טעויות נפוצות
  • אם הפותח לא ציין FILE_SHARE_DELETE, המחיקה עוברת וה-Handle שלו פשוט מפסיק לעבוד. המחיקה עצמה נדחית ב-Sharing Violation, וה-Handle ממשיך לעבוד כרגיל.
  • קובץ נעול אפשר לפחות להעביר לסל המיחזור, והוא יימחק כשה-Handle ייסגר. ההעברה לסל נכשלת מאותה סיבה בדיוק.
  • הקובץ נעול כי הוא בבעלות חשבון מערכת. הנעילה באה מ-Handle פתוח, לא מהבעלות.
  • Windows מחזיקה Handles לקבצים עד האתחול הבא. ה-Handles נסגרים כשהתהליך מסתיים, ואין צורך באתחול.
בדקו את עצמכם
תוכנת גיבוי פתחה את archive.db עם FILE_SHARE_READ ו-FILE_SHARE_WRITE. תוכנה אחרת רוצה לפתוח אותו לכתיבה, ואחר כך למחוק אותו. מה יצליח?

הפתיחה לכתיבה תצליח, כי כתיבה שותפה. המחיקה תיכשל ב-Sharing Violation, כי FILE_SHARE_DELETE לא ניתן.

חזרה לתוכן העניינים

דליפת Handles וזיהוי שלה

דליפת Handles (Handle Leak) נוצרת כשתוכנה פותחת Handles ושוכחת לסגור אותם. התוכנית הבאה עושה את זה בכוונה: היא פותחת מפתח Registry לקריאה 500 פעמים, וקוראת ל-RegCloseKey רק בסוף. את מספר ה-Handles שלה היא מדפיסה בעזרת GetProcessHandleCount, אותו מספר שמופיע בעמודה Handles:

C
#include <windows.h>
#include <stdio.h>

#define ROUNDS 500

static DWORD handles_now(void) {
    DWORD n = 0;
    GetProcessHandleCount(GetCurrentProcess(), &n);
    return n;
}

int main(void) {
    HKEY keys[ROUNDS];
    printf("start           : %lu handles\n", handles_now());

    for (int i = 0; i < ROUNDS; i++) {
        /* bug: the key is opened on every round and never closed */
        RegOpenKeyExW(HKEY_CURRENT_USER, L"Control Panel\\Desktop", 0, KEY_READ, &keys[i]);
        if (i == 99 || i == ROUNDS - 1)
            printf("after %3d rounds: %lu handles\n", i + 1, handles_now());
    }

    for (int i = 0; i < ROUNDS; i++)
        RegCloseKey(keys[i]);            /* the fix: one close per open */
    printf("after RegCloseKey: %lu handles\n", handles_now());
    return 0;
}
פלט
start           : 79 handles
after 100 rounds: 180 handles
after 500 rounds: 580 handles
after RegCloseKey: 80 handles

המספרים המוחלטים תלויים במחשב ובהרצה, ובמחשב אחר הבסיס יכול להיות 85 או 120. מה שחשוב הוא השינוי: כל 100 פתיחות הוסיפו כ-100 Handles, ורק הסגירות החזירו את המונה לסביבת נקודת ההתחלה.

בתוכנה אמיתית לולאת הסגירה פשוט חסרה. למשל, פונקציה שרצה פעם בדקה, פותחת מפתח Registry כדי לבדוק הגדרה, ושוכחת את RegCloseKey באחד הענפים. מה כל Handle כזה עולה:

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

כך תופסים דליפה כזו ב-Task Manager:

  1. עוברים ללשונית Details.
  2. לחיצה ימנית על אחת מכותרות העמודות, Select columns, ומסמנים Handles.
  3. חוזרים להסתכל על הערכים כמה פעמים לאורך שעות או ימים.
  4. תהליך שהמספר שלו רק עולה ואף פעם לא יורד הוא החשוד.
מה בודקיםמתאים לדליפת Handles?
לשונית Usersלא. היא מסכמת צריכה לפי משתמש ואינה סופרת Handles
Commit sizeלא. היא מודדת זיכרון שהוקצה
CPU timeלא. הוא מצטבר אצל כל תהליך שעובד, דולף או לא
עמודת Handles בלשונית Detailsכן, זה בדיוק התפקיד שלה

ומה Task Manager לא יגיד לכם? הוא נותן מספר, וזהו. אילו אובייקטים עומדים מאחורי 37,000 ה-Handles, ואיך סוגרים אחד מהם, תמצאו רק בכלים שבחלק הבא.

תרחיש 15: סוכן עדכונים שמדליף
מדידהHandles של updater.exeHandles של svchost.exe (אחד מהם)
יום ראשון בבוקר6201,480
יום שלישי9,8701,510
יום שבת37,3001,460
  • svchost.exe מחזיק לא מעט Handles, אבל המספר נע סביב אותו ערך. זו התנהגות תקינה.
  • updater.exe מתחיל נמוך ורק מטפס: זו דליפה.
  • אתחול של השירות יאפס את המספר לזמן מה. הפתרון האמיתי הוא תיקון בקוד: CloseHandle או RegCloseKey בכל ענף שבו ה-Handle כבר לא נחוץ.
טעויות נפוצות
  • דליפת Handles מזהים לפי CPU time או Commit size שעולים. העמודות האלה מודדות דברים אחרים. הסימן הוא עמודת Handles שרק עולה.
  • כשהמשאבים מתמלאים, Windows משחררת בעצמה את הישנים ביותר. הם נשארים פתוחים עד שהתוכנה סוגרת אותם או שהתהליך מסתיים.
  • כל Handle פתוח מוסיף נפח ל-Page File. אין קשר בין מספר ה-Handles לגודל ה-Page File.
  • המשתמש יכול לסגור את ה-Handles העודפים ב-Task Manager, או שהם ייסגרו כשיסגור את החלונות. Task Manager לא סוגר Handle בודד, וסגירת חלון לא סוגרת Handles של קבצים.
בדקו את עצמכם
בדליפת זיכרון ובדליפת Handles, באיזו עמודה מסתכלים בכל אחת?

בדליפת זיכרון: Memory, או Commit size, שעולה בלי לרדת. בדליפת Handles: העמודה Handles.

מצאתם ב-Task Manager תהליך עם 50,000 Handles שהולך וגדל. האם אפשר לראות שם לאילו קבצים הם שייכים?

לא. Task Manager מראה רק את המספר. את הרשימה עצמה רואים ב-Process Explorer או ב-Handle.exe.

חזרה לתוכן העניינים

Process Explorer, Handle.exe ו-Process Hacker

כשהשאלה היא מי מחזיק קובץ מסוים, Task Manager לא יענה. Microsoft מספקת לשם כך שני כלים בחבילת Sysinternals, ויש גם כלי שלישי שאינו שלה.

כליסוגמה עושים בו
Process Explorer (procexp.exe), של Sysinternalsגרפיבתפריט Find בוחרים Find Handle or DLL, מקלידים חלק משם הקובץ ומקבלים את כל התהליכים שפתחו אותו. ב-Lower Pane, בתצוגת Handles, רואים את כל ה-Handles של התהליך המסומן, עם הסוג והשם של כל אובייקט. לחיצה ימנית על Handle ואז Close Handle סוגרת אותו
Handle.exe, של Sysinternalsשורת פקודהאותה יכולת חיפוש מתוך מסוף. האפשרות -c, יחד עם -p ו-PID, סוגרת Handle מסוים
Process Hacker (היום בשם System Informer)גרפי, לא של Microsoftחיפוש Handles לפי שם, סגירה של Handle תקוע, וצפייה בהרשאות הגישה של האובייקט ושינוי שלהן, בפירוט רב יותר מ-Task Manager

Process Explorer ו-Process Hacker הם ממשקים גרפיים רגילים, ולכן גם משתמשים מתקדמים שאינם מתכנתים עובדים איתם בלי קושי.

ל-Handle.exe מעבירים חלק משם הקובץ כפרמטר, למשל handle.exe quarterly.pdf. כל שורה בתשובה מציינת את שם התהליך, את ה-PID שלו, את סוג האובייקט (למשל File), את ערך ה-Handle ואת הנתיב המלא. הכלי לא מותקן במחשב שעליו נכתב הפרק, ולכן התשובה שלו מתוארת כאן במילים.

סגירת Handle של תהליך אחר מסוכנת, וכדאי לראות למה, צעד אחר צעד:

  1. בוחרים Close Handle. Process Explorer עוצר ומזהיר שהפעולה עלולה לערער את התהליך או לאבד נתונים. בלי אישור לא קורה דבר.
  2. מאשרים. הרשומה נמחקת מהטבלה של התהליך, ואף אחד לא מודיע לו.
  3. התהליך ממשיך בעבודתו, ובקריאה הבאה עם אותו ערך מקבל שגיאת Handle לא תקף.
  4. תוכנה שלא צפתה את זה עלולה ליפול, או להשאיר אחריה קובץ שנכתב רק בחלקו.
מה סגירת Handle בודד לא עושהבפועל
לא פוגעת בתהליכים אחריםה-Handle היה רשום רק בטבלה של תהליך אחד
לא מסיימת את התהליך, כמו Kill Processהתהליך ממשיך לרוץ בלי ה-Handle
לא מפעילה את התהליך מחדש ולא שומרת את הנתונים שלוהכלי רק מוחק רשומה אחת
לא גורמת ל-Windows לפתוח את ה-Handle מחדשהוא נעלם, עד שהתוכנה עצמה תפתח חדש

וגם כמה כלים שלא יעזרו כאן:

  • Event Viewer: כברירת מחדל הוא לא מתעד איזה תהליך פתח כל קובץ.
  • Device Manager: עוסק בהתקני חומרה ובדרייברים.
  • Disk Cleanup: מוחק קבצים זמניים, ולא נוגע ב-Handles.
  • עריכה ב-Registry: אין שם רשומה שמחזיקה Handle פתוח.
  • הפעלה מחדש של explorer.exe: סוגרת רק את ה-Handles ש-explorer.exe עצמו החזיק, ולא את אלה של תוכנות אחרות.
  • שינוי עדיפות של Handle: אין דבר כזה. עדיפות היא תכונה של תהליכים ושל Threads.
תרחיש 16: קובץ נתונים שלא נותן למחוק אותו
  1. אי אפשר למחוק את dataset_2025.parquet, ואין שום חלון פתוח שקשור אליו.
  2. ב-Process Explorer: Find, Find Handle or DLL, ומקלידים dataset_2025.
  3. התוצאה: python.exe עם PID 3384 מחזיק Handle מסוג File לקובץ.
  4. האפשרות הבטוחה: לסיים את python.exe. Windows תסגור את כל ה-Handles שלו, והמחיקה תעבור.
  5. האפשרות המסוכנת: Close Handle רק על ה-Handle הזה, אחרי האזהרה. הסקריפט ימשיך לרוץ ועלול להיכשל או לכתוב נתונים חלקיים.
טעויות נפוצות
  • Task Manager חושף אילו קבצים פתח כל תהליך, ואפשר גם לסגור דרכו Handle. הוא מציג רק את מספר ה-Handles, ולא מאפשר לסגור אף אחד מהם.
  • Close Handle ב-Process Explorer מסיים את התהליך. התהליך ממשיך לרוץ, ועלול להיתקל בשגיאות כשינסה להשתמש ב-Handle.
  • סגירת Handle פוגעת גם בשאר התהליכים שהמשתמש מריץ. ה-Handle שייך לטבלה של תהליך אחד בלבד.
  • Process Explorer מאתחל את התהליך ושומר את הנתונים שלו, ולכן אין נזק. הכלי לא מאתחל ולא שומר דבר. הוא רק סוגר את ה-Handle.
בדקו את עצמכם
בשרת Windows Server Core, בלי ממשק גרפי, צריך לגלות מי מחזיק את web.config. איזה כלי מתאים?

Handle.exe, כלי שורת הפקודה של Sysinternals.

מה ההבדל, מבחינת התהליך שמחזיק את הקובץ, בין Close Handle לבין סיום התהליך?

סיום עוצר את התהליך, ו-Windows סוגרת את כל ה-Handles שלו. Close Handle משאיר אותו רץ בלי ה-Handle, והוא עלול להיתקל בשגיאות.

חזרה לתוכן העניינים

HWND ואובייקטי GDI: ידיות שאינן בטבלת ה-Handles

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

עמודה ב-Task Managerמה נספר בהמי מנהלאיך משחררים
Handlesאובייקטי ליבה: קבצים, מפתחות Registry, Threads, Mutexהליבה, בטבלת ה-Handles של התהליךCloseHandle, וגם RegCloseKey או FindClose
USER objectsחלונות (HWND), תפריטים, פקדיםתת-מערכת USER, בלי טבלת ה-Handlesחלון: DestroyWindow
GDI objectsעטים, מברשות, גופנים, bitmapsתת-מערכת GDI, בלי טבלת ה-Handlesפונקציות השחרור של GDI, למשל DeleteObject

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

C
#include <windows.h>
#include <stdio.h>

static void show(const char *when) {
    DWORD handles = 0;
    GetProcessHandleCount(GetCurrentProcess(), &handles);
    printf("%-22s Handles=%lu  USER=%lu  GDI=%lu\n", when, handles,
           GetGuiResources(GetCurrentProcess(), GR_USEROBJECTS),
           GetGuiResources(GetCurrentProcess(), GR_GDIOBJECTS));
}

int main(void) {
    HWND wins[20];
    HPEN pens[20];
    /* the first window of a process sets up its GUI connection: do it once up front */
    HWND warm = CreateWindowExW(0, L"STATIC", L"warm-up", 0, 0, 0, 10, 10, NULL, NULL, NULL, NULL);
    show("start:");

    for (int i = 0; i < 20; i++)
        wins[i] = CreateWindowExW(0, L"STATIC", L"panel", WS_OVERLAPPEDWINDOW,
                                  0, 0, 100, 100, NULL, NULL, NULL, NULL);
    show("after 20 windows:");

    for (int i = 0; i < 20; i++)
        pens[i] = CreatePen(PS_SOLID, 1 + i, RGB(i, 0, 0));
    show("after 20 pens:");

    for (int i = 0; i < 20; i++) {
        DestroyWindow(wins[i]);           /* windows are freed with DestroyWindow */
        DeleteObject(pens[i]);            /* GDI objects with DeleteObject */
    }
    DestroyWindow(warm);
    show("after cleanup:");
    return 0;
}
פלט
start:                 Handles=116  USER=3  GDI=0
after 20 windows:      Handles=116  USER=23  GDI=0
after 20 pens:         Handles=116  USER=23  GDI=20
after cleanup:         Handles=114  USER=1  GDI=0

20 החלונות הוסיפו 20 למונה USER, ו-20 העטים הוסיפו 20 למונה GDI, ובאותו זמן עמודת Handles לא זזה. כלומר חלונות שתוכנה פותחת לא נספרים בעמודה Handles, ואת החלון עצמו גם לא סוגרים ב-CloseHandle. המונים המוחלטים משתנים ממחשב למחשב; המשמעות היא בהפרשים.

טעויות נפוצות
  • עמודת Handles מראה כמה חלונות פתח התהליך. חלונות הם USER objects, ונספרים בעמודה USER objects.
  • אפשר לסגור חלון בקריאה ל-CloseHandle על ה-HWND שלו. HWND אינו רשום בטבלת ה-Handles. חלון סוגרים ב-DestroyWindow.
בדקו את עצמכם
תוכנת ציור יוצרת 40 מברשות ו-40 גופנים ולא משחררת אותם. איזו עמודה תעלה?

GDI objects.

דפדפן פותח 12 חלונות חדשים. איזו עמודה תעלה, ואיזו לא תושפע מהחלונות עצמם?

USER objects תעלה. עמודת Handles לא סופרת חלונות.

חזרה לתוכן העניינים

Desktop: מילה אחת, ארבעה דברים שונים

שולחן העבודה שרואים: explorer.exe

ב-Windows המילה Desktop משמשת לארבעה דברים נפרדים, ובחלק הזה נעבור על כל אחד מהם:

כשאומרים Desktop, מתכוונים ל...דוגמה
Desktop וירטואליקבוצת חלונות נפרדת שפותחים ב-Task View (Win+Tab)
התמונה שעל המסך: רקע, אייקונים ושורת המשימותמה ש-explorer.exe מצייר
אובייקט של מערכת ההפעלה שמכיל חלונותה-Desktop הרגיל, וה-Secure Desktop של UAC
תיקייה בדיסקהמקום שבו נשמר קובץ שגררתם לשולחן העבודה

נתחיל במה שהעין רואה. הרקע, האייקונים, שורת המשימות ותפריט Start הם עבודה של תהליך אחד, explorer.exe, שמשמש shell (מעטפת) של Windows ומריץ גם את חלונות File Explorer. כדאי לא לבלבל אותו עם שכניו ברשימת התהליכים:

תהליךהתפקידמצייר את שולחן העבודה?
explorer.exeשולחן העבודה, שורת המשימות ותפריט Startכן
lsass.exeאימות משתמשים בכניסה ויצירת Access Tokensלא, אין לו ממשק
services.exeService Control Manager: הפעלה וניהול של שירותי הרקעלא
taskmgr.exeTask Manager, אפליקציה שמראה תהליכים ומשאביםלא, רק את החלון של עצמו

שתי פעולות שאפשר לעשות ב-Task Manager על התהליך הזה, ומה כל אחת משאירה אחריה. בלשונית Processes, כשמסמנים את Windows Explorer, במקום הכפתור End task מופיע Restart:

סיום (End task ב-Details)Restart בלשונית Processes
אייקונים, רקע ושורת משימותנעלמים ולא חוזרים לבדנעלמים לרגע ומצוירים מחדש
תוכנות אחרות וחלונותיהןממשיכות לרוץ, והחלונות נשארים על המסךממשיכות לרוץ
המשתמש והמערכתהמשתמש נשאר מחובר ואין קריסה, כי explorer.exe אינו תהליך קריטיכמו בעמודה הקודמת
איך חוזריםבתפריט File בוחרים Run new task ומקלידים explorer.exeאין צורך: הסגירה וההפעלה קורות בלחיצה אחת
מתי זה שימושיכמעט אף פעם בכוונהכששורת המשימות או תפריט Start נתקעים
תרחיש 17: תפריט Start שלא נפתח
  1. תפריט Start ושורת המשימות לא מגיבים ללחיצות, אבל נגן המוזיקה ממשיך לנגן ועורך הטקסט מקבל הקלדה.
  2. Ctrl+Shift+Esc פותח את Task Manager. בלשונית Processes מסמנים Windows Explorer ולוחצים Restart.
  3. לרגע אין על המסך אייקונים ולא שורת משימות, ומיד הם מופיעים שוב ומגיבים.
  4. הנגן והעורך לא הושפעו, כי הם תהליכים נפרדים.
טעויות נפוצות
  • סיום explorer.exe יפיל את Windows למסך כחול. מסך כחול נגרם מסיום של תהליך קריטי כמו csrss.exe. explorer.exe אינו כזה.
  • בלי explorer.exe כל התוכנות הפתוחות נסגרות, או שהמשתמש מנותק. שאר התוכנות ממשיכות לרוץ, וההתחברות לא תלויה ב-explorer.exe.
  • את שורת המשימות מצייר lsass.exe או services.exe. lsass.exe מאמת משתמשים ו-services.exe מנהל שירותים. שורת המשימות היא של explorer.exe.
בדקו את עצמכם
בלחיצה לא זהירה בלשונית Details סיימתם את explorer.exe, ועל המסך נשאר רק חלון Task Manager. איך מחזירים את שולחן העבודה?

בתפריט File בוחרים Run new task, ומקלידים explorer.exe.

חזרה לתוכן העניינים

התיקייה שמאחורי שולחן העבודה

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

Text
C:\Users\<user name>\Desktop

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

נתיבמה יש בושולחן העבודה?
C:\Users\<שם>\Desktopהקבצים שעל שולחן העבודה של אותו משתמשכן
C:\Windowsההתקנה של Windows עצמה (%SystemRoot%)לא
C:\Users\<שם>\AppDataהגדרות ונתונים של תוכנות, לכל משתמש בנפרדלא
C:\Users\<שם>\Documentsהמסמכים של המשתמשלא
C:\ProgramDataנתוני תוכנות שמשותפים לכל המשתמשיםלא
תרחיש 18: קובץ שהמשתמשת noa שמרה
  • noa שומרת את budget.pptx ישירות על שולחן העבודה.
  • בדיסק הקובץ נמצא ב-C:\Users\noa\Desktop\budget.pptx.
  • הפקודה dir C:\Users\noa\Desktop ב-cmd תציג אותו ברשימה, כמו כל קובץ אחר בתיקייה.
טעויות נפוצות
  • שולחן העבודה שמור בתוך C:\Windows. C:\Windows מכילה את מערכת ההפעלה. שולחן העבודה הוא חלק מפרופיל המשתמש.
  • שולחן העבודה הוא תת-תיקייה של AppData, של Documents או של ProgramData. היא יושבת ישירות תחת תיקיית הפרופיל:C:\Users\<שם>\Desktop.
בדקו את עצמכם
באיזה נתיב יישמר קובץ שהמשתמש support3 גורר לשולחן העבודה?

C:\Users\support3\Desktop.

חזרה לתוכן העניינים

Desktop כאובייקט: Window Station ו-Secure Desktop

נתחיל מתוכנית קטנה ששואלת את Windows איפה היא נמצאת מבחינה גרפית. היא קוראת ל-GetUserObjectInformationW פעמיים: פעם על ה-Window Station של התהליך, ופעם על ה-Desktop של ה-Thread:

C
#include <windows.h>
#include <stdio.h>

static void print_name(HANDLE obj, const char *what) {
    wchar_t name[256];
    DWORD needed = 0;
    if (GetUserObjectInformationW(obj, UOI_NAME, name, sizeof(name), &needed))
        printf("%-15s %ls\n", what, name);
}

int main(void) {
    print_name(GetProcessWindowStation(), "window station:");
    print_name(GetThreadDesktop(GetCurrentThreadId()), "desktop:");
    return 0;
}
פלט
window station: WinSta0
desktop:        Default

שני שמות, שני אובייקטים של מערכת ההפעלה. Default הוא Desktop: המכל שבו חיים החלונות, התפריטים והפקדים של התוכנית ודרכו הם מוצגים, כלומר סביבת עבודה גרפית. הוא לא קובץ, לא תהליך ולא ערך שמור ב-Registry.

WinSta0 הוא Window Station, תחנת חלונות, והוא העוטף: Desktops נמצאים בתוך Window Station, ולא להפך. WinSta0 היא התחנה האינטראקטיבית של מי שיושב מול המסך, ולכן התוכנית, שרצה תחת המשתמש המחובר, נמצאת בה. יש בה יותר מ-Desktop אחד:

Text
WinSta0                  interactive window station
  +- Default             the user's desktop: apps, explorer.exe
  +- Winlogon            secure: Ctrl+Alt+Del menu and UAC consent
רכיבמה הוא עושהמה הוא לא
Sessionהקשר ההתחברות של משתמש, מהכניסה ועד היציאהמושג נפרד מ-Desktop
Desktop (האובייקט)מחזיק את החלונות וקובע לאיזה Desktop כל חלון שייךלא מצייר רקע ואייקונים
explorer.exeמצייר רקע, אייקונים ושורת משימותהוא לא ה-Desktop עצמו, אלא תוכנה שרצה עליו
מנהל ההתקן הגרפי (GPU driver)הופך את התמונה לפיקסלים על המסךלא מחליט איזה חלון שייך לאיזה Desktop

Secure Desktop. שימו לב לשורה Winlogon בעץ. זה Desktop שני באותה תחנה, ו-Windows מציגה עליו את מסך Ctrl+Alt+Del ואת בקשת האישור של UAC (User Account Control), ברמת ברירת המחדל וברמה שמעליה. קוראים לו Secure Desktop, ומה שהופך אותו לבטוח הוא החומה שבין Desktops:

תוכנה שרצה ב-Default מנסה, כלפי חלון ב-Winlogon...אפשרי?
לשלוח אליו הקשות או לחיצות עכברלא
לקרוא את התוכן שלולא
לשנות אותולא
להעמיד במקומו חלון מזויף שנראה כמו הבקשהלא

חשבו מה היה קורה בלי החומה: תוכנה זדונית שרצה אצל המשתמש הייתה מייצרת בעצמה לחיצה על Yes ומקבלת הרשאות מנהל בלי שאיש ראה. לכן הבקשה עוברת ל-Winlogon, ומה שנשאר מאחוריה, מוחשך, הוא רק תמונה של Default ולא החלונות החיים.

רמת UACאיפה מוצג חלון האישור
Always notifySecure Desktop, עם החשכה
Notify me only when apps try to make changes (ברירת המחדל)Secure Desktop, עם החשכה
Notify me only when apps try to make changes (do not dim my desktop)ה-Desktop הרגיל, בלי החשכה
Never notifyלא מוצג חלון
ה-Secure Desktop לא סורק את התוכנה שביקשה הרשאות, לא מתעד דבר לביקורת, לא חוסך זיכרון, וגם לא מקדם את החלון במעבד או מזרז את הופעתו. כל מה שהוא נותן הוא בידוד.

שני מנגנוני בידוד שקל לערבב:

Secure DesktopSession 0
מה זהDesktop בשם Winlogon, בתוך WinSta0 של המשתמשה-Session שבו רצים שירותי המערכת, מבודד מה-Session של המשתמש החל מ-Windows Vista
הקשר ל-UACמציג את בקשת האישוראין: הבקשה לא מוצגת שם, והתוכנה שביקשה הרשאות לא עוברת לרוץ שם
תרחיש 19: ניסיון לאשר UAC בלי המשתמש
  1. סקריפט זדוני שרץ בחשבון של אבי מפעיל תוכנית שדורשת הרשאות מנהל.
  2. UAC מוגדר לרמת ברירת המחדל, ולכן חלון האישור עולה על ה-Secure Desktop.
  3. הסקריפט מייצר הקשת Enter ולחיצת עכבר, אבל הן נשארות ב-Desktop הרגיל שבו הוא רץ, ולא מגיעות לחלון האישור.
  4. רק אבי, מול המקלדת והעכבר האמיתיים, יכול לאשר או לסרב.
  5. אילו UAC היה מוגדר ל-do not dim my desktop, החלון היה מופיע על ה-Desktop הרגיל, וההגנה הזו הייתה נעלמת.
טעויות נפוצות
  • Desktop מכיל Window Station. ההפך: Window Station מכילה Desktops.
  • ה-Secure Desktop קיים כדי לזרז את חלון UAC או לתת לו עדיפות במעבד. הוא קיים כדי שתוכנות לא יוכלו לגעת בחלון.
  • ברמת ברירת המחדל, חלון UAC מופיע על ה-Desktop של המשתמש. זה קורה רק ברמה do not dim my desktop.
  • חלון UAC מוצג ב-Session 0, או שהתוכנה המבקשת עוברת לרוץ שם. Session 0 הוא המקום של השירותים, ואין לו קשר לחלון האישור.
  • חלון UAC נפתח על Desktop וירטואלי חדש של Win+Tab. Desktops וירטואליים הם תכונה לארגון חלונות, לא מנגנון אבטחה.
  • Desktop הוא בסך הכול הרקע והקיצורים, או רשומת הגדרות ב-Registry. הוא אובייקט מערכת שמחזיק את החלונות.
בדקו את עצמכם
לחצתם Ctrl+Alt+Delete. על איזה Desktop מוצג המסך שעולה?

על ה-Secure Desktop, ה-Desktop בשם Winlogon.

WinSta0 ו-Default: מה מכיל את מה?

WinSta0 היא Window Station, ו-Default הוא אחד ה-Desktops שבתוכה.

למה שינוי UAC לרמה do not dim my desktop מחליש את ההגנה?

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

חזרה לתוכן העניינים

Desktops וירטואליים

פתחו את Task View בשורת המשימות, ולצד החלונות הפתוחים תראו גם רשימה של שולחנות עבודה. כל אחד מהם הוא Desktop וירטואלי: שולחן עבודה לוגי שמחזיק קבוצת חלונות משלו. התכונה מגיעה עם Windows 10 ועם Windows 11, בלי שום התקנה.

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

רוציםעושים
Desktop חדשTask View בשורת המשימות (או Win+Tab) ואז New desktop, או ישירות Win+Ctrl+D
לעבור ל-Desktop אחרWin+Ctrl עם חץ ימינה או שמאלה, או בחירה ב-Task View
לסגור את ה-Desktop הנוכחיWin+Ctrl+F4. החלונות שהיו בו עוברים ל-Desktop השכן

חשוב להבין גם מה זה לא. כל ה-Desktops הווירטואליים רצים באותה מערכת הפעלה, תחת אותו משתמש ובאותו Session, והמעבד, הזיכרון וכרטיס המסך משותפים לכולם.

ציפייההמציאות
זה כמו ה-Secure Desktopאין להם קשר ל-Secure Desktop או ל-UAC
אפשר לנעול Desktop בסיסמה או לתת לו הרשאות אחרותאין הרשאות או סיסמאות נפרדות
כל Desktop הוא עותק נפרד של Windowsמערכת אחת, משתמש אחד, Session אחד
לכל Desktop חומרה משלואותו מעבד, אותו RAM, אותו כרטיס מסך
Desktops מזרזים פתיחה של תוכנות, או משתפים תהליכים עם מחשב אחרהם רק מקבצים חלונות
אפשר ליצור Desktop וירטואלי ב-mkdir, במפתח Registry או ב-Display settingsmkdir יוצר תיקייה, מפתח Registry לא יוצר שולחן עבודה, ו-Display settings מטפל במסכים פיזיים. יוצרים רק ב-Task View או ב-Win+Ctrl+D
תרחיש 20: סטודנטית עם שני עולמות
  • מאיה כותבת עבודה סמינריונית במעבד תמלילים, עם PDF ודפדפן מלא מאמרים, ובמקביל מנהלת חנות מקוונת קטנה בדפדפן נוסף, עם גיליון מלאי ואפליקציית הודעות.
  • היא לוחצת Win+Ctrl+D, מקבלת Desktop 2 ומעבירה אליו את חלונות החנות.
  • Win+Ctrl עם החצים מחליף בין שתי קבוצות החלונות בלי לסגור דבר.
  • ב-Task Manager היא רואה את התהליכים של שני ה-Desktops ברשימה אחת, כי יש כאן מערכת אחת ומשתמש אחד.
טעויות נפוצות
  • כל Desktop וירטואלי מריץ Windows משלו, ואולי אפילו כרטיס מסך משלו. כל ה-Desktops חולקים את אותה מערכת ואת אותה חומרה.
  • אפשר להגדיר לכל Desktop וירטואלי סיסמה או הרשאות. כולם שייכים לאותו משתמש.
  • Desktop וירטואלי יוצרים ב-mkdir או במפתח Registry. יוצרים אותו ב-Task View או ב-Win+Ctrl+D.
בדקו את עצמכם
ב-Desktop 3 רץ רינדור שתופס 70% מהמעבד. האם זה ירגיש גם ב-Desktop 1?

כן. יש מעבד אחד, והוא משותף לכל ה-Desktops הווירטואליים.

סגרתם ב-Win+Ctrl+F4 Desktop שהיו בו שלושה חלונות. מה קרה להם?

הם לא נסגרו. הם עברו ל-Desktop הסמוך.

חזרה לתוכן העניינים

סיכום

חמשת המושגים של הפרק בנקודות שכדאי לזכור לפני מבחן:

Task Manager

  • Ctrl+Shift+Esc פותח את taskmgr.exe בלי תחנת ביניים. Ctrl+Alt+Delete מציג קודם את מסך האבטחה.
  • הלשוניות: Processes מראה מי צורך משאבים, Performance מציג גרפים של המערכת כולה, Startup מרכז תוכנות שעולות בכניסה, Users מסכם לפי משתמש, Services מציג שירותים, ו-Details מציג PID, עדיפות ו-Affinity.
  • ב-Details מוסיפים עמודות בלחיצה ימנית על כותרת ובחירה ב-Select columns: Threads, Handles, USER objects, GDI objects, Commit size.
  • End task ב-Processes מבקש מהתוכנה להיסגר, ב-Details הסיום מיידי, ו-End process tree מסיים גם את כל הצאצאים.
  • סיום csrss.exe, wininit.exe או smss.exe מפיל את המערכת למסך כחול, וסיום lsass.exe מוביל להפעלה מחדש.
  • Priority Class, מהגבוהה לנמוכה: Realtime, High, Above normal, Normal, Below normal, Low. Realtime עלול להקפיא את המערכת.
  • Disable בלשונית Startup מונע עלייה אוטומטית, בלי להסיר את התוכנה.
  • Show kernel times מפעילים בלחיצה ימנית על גרף ה-CPU בלשונית Performance, ושם מופיעים גם הסכומים של Processes, Threads ו-Handles.
  • דליפת זיכרון מתגלה בעמודת Memory שעולה בהתמדה. לתהליך תקוע כדאי Analyze wait chain ו-Create dump file לפני שמסיימים אותו.

Thread

  • Thread הוא יחידת הביצוע בתוך תהליך. ה-Threads של תהליך חולקים מרחב כתובות וטבלת Handles, ולכל אחד stack, אוגרים ו-TID משלו.
  • המתזמן מקצה זמן מעבד ל-Threads ולא לתהליכים: לפי עדיפות, עם הפקעה (preemptive), ב-Round Robin עם Quantum בין Threads בעדיפות שווה, ועל פני כל הליבות.
  • Priority Boost מעלה עדיפות לזמן קצר אחרי המתנה לקלט או פלט, או אחרי הרעבה, והתוספת דועכת בהדרגה.
  • יותר מדי Threads מוסיפים עומס של Context Switch. נתונים משותפים בלי סנכרון מובילים ל-race condition, ולכן משתמשים ב-critical section או ב-mutex.
  • Task Manager לא מראה צריכת CPU לכל Thread בנפרד. את זה מראה Process Explorer.

Page File

  • C:\pagefile.sys מגבה זיכרון פרטי ששונה. דפי קוד ודפים של קבצים ממופים שלא שונו לא נכתבים אליו.
  • Commit Limit הוא RAM ועוד Page File. כשההתחייבויות מגיעות אליו, הקצאות נכשלות גם כשיש RAM פנוי.
  • Working Set הוא מה שהתהליך מחזיק כרגע ב-RAM. Commit Charge הוא כל מה שהוקצה, כולל מה שיושב ב-Page File.
  • Paged Pool של הליבה מותר להעברה לדיסק, ו-Non-Paged Pool נשאר תמיד ב-RAM.
  • את הגודל קובעים ב-System Properties, Advanced, Performance, Virtual memory. אפשר קובץ בכמה כוננים, וכונן מהיר משפר רק את המהירות.
  • Thrashing פירושו RAM קטן מקבוצת העבודה: דיסק עמוס ומעבד רגוע. הפתרון הוא RAM או פחות תוכנות, לא Page File גדול יותר.
  • Crash dump נכתב קודם ל-Page File בכונן של Windows, ובאתחול הבא עובר ל-%SystemRoot%\MEMORY.DMP. Complete dump דורש Page File בגודל ה-RAM.
  • המדיניות Shutdown: Clear virtual memory pagefile דורסת את הקובץ בכל כיבוי.

Handle

  • Handle הוא ערך אטום ברשומה בטבלת ה-Handles של תהליך. הוא תקף רק בתהליך הזה, אלא אם הועבר בירושה או ב-DuplicateHandle.
  • בכל פתיחה Security Reference Monitor בודק אם ה-ACL של האובייקט מתיר את הגישה למשתמש ולקבוצות שב-Access Token.
  • CreateFile נכשלת עם INVALID_HANDLE_VALUE (-1), ורוב פונקציות ה-Create האחרות עם NULL. את הסיבה קוראים מיד ב-GetLastError.
  • סוגרים ב-CloseHandle, וכשתהליך מסתיים Windows סוגרת כל Handle שנשאר שלו.
  • בלי FILE_SHARE_DELETE, מחיקה נכשלת ב-Sharing Violation עד שה-Handle נסגר.
  • דליפת Handles רואים בעמודת Handles שעולה בלי הפסקה בלשונית Details.
  • Process Explorer, Handle.exe ו-Process Hacker מראים מי מחזיק קובץ ויכולים לסגור Handle בודד, אחרי אזהרה.
  • HWND ואובייקטי GDI אינם בטבלת ה-Handles. הם נספרים בעמודות USER objects ו-GDI objects.

Desktop

  • את הרקע, האייקונים ושורת המשימות מצייר explorer.exe. סיום שלו מעלים רק אותם, ומחזירים אותו ב-Run new task.
  • הקבצים של שולחן העבודה יושבים ב-C:\Users\<שם>\Desktop.
  • כאובייקט, Desktop מחזיק חלונות ושייך ל-Window Station. ה-Secure Desktop (Winlogon) מציג את Ctrl+Alt+Del ואת UAC ברמות ברירת המחדל, ותוכנות אחרות לא יכולות לגעת בו.
  • Desktops וירטואליים פותחים ב-Task View, New desktop, או ב-Win+Ctrl+D. כולם באותה מערכת, תחת אותו משתמש ועל אותה חומרה.