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 משתנים בכל הרצה, ולכן אצלכם יופיעו ערכים אחרים.
רקע: תהליך, זיכרון ואובייקטים של הליבה
תוכנית, תהליך ו-PID
ההבחנה הראשונה היא בין מה ששוכב בדיסק לבין מה שרץ. קובץ כמו calc.exe הוא תוכנית (program): רצף הוראות שמחכה שמישהו יפעיל אותו. ברגע ההפעלה נוצר תהליך (process), כלומר מופע חי של אותה תוכנית.
מכאן שלתוכנית אחת יכולים להיות כמה תהליכים בו-זמנית. הפעלתם את אותו נגן פעמיים? יש קובץ אחד בדיסק ושני תהליכים בזיכרון, ו-Windows מבחינה ביניהם בעזרת מספר שהיא נותנת לכל תהליך: PID, קיצור של Process ID.
כאן הופעלה פעמיים תוכנית קטנה בשם radio.exe, ואז נשאלה Windows אילו תהליכים בשם הזה קיימים:
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 פורש את החלון המלא עם כל הלשוניות.
טעויות נפוצות
- 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 impact | Disable ו-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.
טעויות נפוצות
- כדי לגלות איזה תהליך זולל הכי הרבה, נכנסים ל-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 | מספר הזיהוי של התהליך, והדרך להבדיל בין שני תהליכים בעלי אותו שם |
| Status | Running, 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 task | Processes | קודם בקשה רגילה להיסגר, כמו לחיצה על ה-X של החלון. רק אם האפליקציה לא נענית, הסגירה נכפית |
| End task (ב-Windows 7: End process) | Details | עצירה מיידית, בלי לשאול את התוכנה. מה שלא נשמר הולך לאיבוד |
| End process tree | Details | עצירה מיידית של התהליך שנבחר ושל כל הצאצאים שלו, כלומר התהליכים שהוא הפעיל |
End process tree עובר רק על העץ שמתחיל בתהליך שבחרתם. תהליך אחר של אותו משתמש, שלא נולד ממנו, לא נפגע:
תרחיש 2: עץ תהליכים בשורת הפקודה
לפעולה הזו יש מקבילה בשורת הפקודה: taskkill עם /T, שמוסיף את הצאצאים, ו-/F, שכופה סיום. כאן installer.exe (PID 19324) הפעיל שני תהליכי napper.exe, ובמקביל רץ editor.exe שהופעל בנפרד:
taskkill /T /F /PID 19324
tasklist /FI "IMAGENAME eq napper.exe" /NH
tasklist /FI "IMAGENAME eq editor.exe" /NHSUCCESS: 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 מבקש אישור, ומזהיר ששינוי כזה בתהליכים מסוימים עלול לערער את יציבות המערכת.
שש המחלקות, מהעליונה לתחתונה:
- Realtime: העליונה מכולן
- High
- Above normal
- Normal: ברירת המחדל של כמעט כל תהליך
- Below normal
- 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 use | RAM שתפוס כרגע |
| Available | RAM שאפשר לתת מיד למי שיבקש |
| Committed | זוג מספרים X/Y: כמה זיכרון כבר הוקצה (Commit charge) מתוך התקרה (Commit limit). נרחיב בחלק על Page File |
| Cached | זיכרון שמחזיק עותקים של קבצים מהדיסק לגישה מהירה |
| Paged pool | זיכרון של הליבה שמותר להוציא ל-Page File |
| Non-paged pool | זיכרון של הליבה שלעולם אינו עוזב את ה-RAM |
טעויות נפוצות
- 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:00 | 14:20 | 14:40 | 15:00 |
|---|---|---|---|---|
| render.exe | 3,400 MB | 3,420 MB | 3,390 MB | 3,410 MB |
| syncd.exe | 90 MB | 260 MB | 430 MB | 610 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) ומשחררת אותם יחד, כך ששניהם חיים באותו זמן:
#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 יש לה:
#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 שלה:
#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$p = Get-Process -Name prio
'Threads: ' + $p.Threads.Count + ' Handles: ' + $p.HandleCount + ' Class: ' + $p.PriorityClass
$p.Threads | Format-Table Id, BasePriority, PriorityLevel -AutoSizeThreads: 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, שמבצעת את ההוספה כצעד שאי אפשר לקטוע:
#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 מדפיסות כמה זמן מעבד צבר כל אחד:
#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 רגיל לא מוצא את הקובץ:
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:
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כך נראה המחזור של דף שנשלח לדיסק וחוזר:
- ה-RAM מתקרב לקצה, ו-Windows מחפשת דפים שאפשר לפנות.
- המועמדים הם דפים של זיכרון פרטי שהתהליך כבר כתב בהם, ושאיש לא נגע בהם בזמן האחרון.
- התוכן שלהם מועתק ל-Page File, והמקום שלהם ב-RAM מתפנה לטובת מי שצריך אותו עכשיו.
- אם התהליך פונה שוב לכתובת שהדף שלה בחוץ, נוצר 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 מחזירה את נתוני ההתחייבות של המערכת, והתוכנית הבאה רק קוראת אותם ולא משנה דבר:
#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 של קריאה בלבד), במגה-בייטים:
Get-CimInstance Win32_PageFileUsage | Select-Object Name,AllocatedBaseSize,CurrentUsage | Format-ListName : 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 גם לא תמחק קבצים כדי להרחיב אותה |
תרחיש 9: קריאת השורה Committed בלשונית Performance
תחנת עבודה עם 12 GB RAM ו-Page File קבוע של 6 GB. תחת Memory בלשונית Performance מופיעים הנתונים האלה:
| שדה | ערך |
|---|---|
| In use | 4.1 GB |
| Available | 7.6 GB |
| Committed | 17.7/18.0 GB |
- התקרה היא 12 ועוד 6, כלומר 18 GB, וזה המספר שאחרי הלוכסן.
- ההתחייבויות עומדות על 17.7 GB, צמוד לתקרה. הקצאה גדולה נוספת עלולה להידחות.
- ה-RAM רחוק מלהתמלא: In use מראה 4.1 GB בלבד.
- Committed לא אומר כמה מהקובץ בדיסק כבר מלא, ואין לו קשר לנתון Cached של המטמון.
- אם התקרה תיפרץ, 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. כך מגיעים להגדרה:
- מקישים Win+R, כותבים
sysdm.cplומאשרים. נפתח System Properties. - בלשונית Advanced, במסגרת Performance, לוחצים על Settings.
- נפתח Performance Options. עוברים גם בו ללשונית Advanced, ובמסגרת Virtual memory לוחצים על Change.
- מורידים את הסימון מ-Automatically manage paging file size for all drives. בלי זה שאר האפשרויות נעולות.
- מסמנים כונן ברשימה, בוחרים Custom size, ממלאים Initial size ו-Maximum size במגה-בייטים ולוחצים Set.
- רוצים 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.
sysdm.cpl, לשונית Advanced, כפתור Settings תחת Performance, שוב לשונית Advanced, ו-Change תחת Virtual memory.- מבטלת את הניהול האוטומטי לכל הכוננים.
- מסמנת את C, בוחרת Custom size, כותבת 6144 בשני השדות ולוחצת Set.
- מסמנת את 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, כלומר הניקוי כבוי:
reg query "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management" /v ClearPageFileAtShutdownHKEY_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. הליבה מחזיקה פנקס כזה לכל תהליך, ובכל רשומה כתוב לאיזה אובייקט הערך מוביל ואיזו גישה אושרה כשנפתח. כך נראית טבלה כזו, באיור:
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 עם מושגים אחרים, ולכן כדאי לראות במה הוא שונה מכל אחד מהם:
| מושג שמתבלבלים איתו | ההבדל |
|---|---|
| מזהה גלובלי של האובייקט | אותו ערך בתהליך אחר לא מוביל לאותו אובייקט |
| PID | PID מזהה תהליך שלם, ו-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 של המבקש |
כשהפתיחה נכשלת, חשוב לדעת איך הכישלון נראה, כי הוא לא אחיד בכל הפונקציות:
| פונקציות | בהצלחה | בכישלון |
|---|---|---|
| CreateFile | Handle תקף | INVALID_HANDLE_VALUE, שערכו -1 ולא 0 |
| רוב פונקציות ה-Create האחרות: CreateThread, CreateMutex, CreateEvent | Handle תקף | NULL, כלומר 0 |
בשני המקרים הפונקציה לא מחזירה את קוד השגיאה במקום ה-Handle, וגם לא יוצרת אובייקט חלופי. את הסיבה מקבלים מ-GetLastError, מיד אחרי הכישלון ולפני כל קריאה אחרת שעלולה לדרוס אותה. למשל, 5 הוא ERROR_ACCESS_DENIED, חוסר הרשאה.
התוכנית הבאה מכשילה בכוונה שתי פתיחות: קובץ בתיקייה שלא קיימת, ו-Mutex בשם שכבר תפוס בידי Event:
#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=6CreateFileW החזירה -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 בתוך אותו תהליך, כדי לראות שהערך משתנה והאובייקט נשאר אחד. אחר כך היא סוגרת את המקור ובודקת את שני הערכים:
#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: אותו מספר בשני תהליכים
- התהליך
payroll.exe(PID 7804) פותח אתsalaries.xlsxומקבל את הערך 0x2C8. - התהליך
report.exe(PID 9112), של אותו משתמש, קורא ל-WriteFile עם 0x2C8. - בטבלה של
report.exeאין רשומה בערך הזה, והקריאה נכשלת בשגיאת Handle לא תקף. - אילו
report.exeהחזיק במקרה 0x2C8 פתוח לקובץ הלוג שלו, הכתיבה הייתה הולכת לשם, ולא לגיליון שלpayroll.exe. - כדי ש-
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 פתוח:
#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 על הקובץ.
- סגירת החלון לא סיימה את התהליך, אלא העבירה אותו לרקע, לפעמים עם אייקון באזור ההודעות שליד השעון.
אז מה עושים? לא מאתחלים את המחשב, אלא מוצאים איזה תהליך מחזיק את הקובץ, וזה התפקיד של Process Explorer ו-Handle.exe שבסוף החלק, ומסיימים אותו, למשל מלשונית Details ב-Task Manager. ברגע שהוא יוצא, ה-Handle נסגר והקובץ משתחרר.
תרחיש 14: נגן שנסגר רק למראית עין
- רון סוגר את חלון נגן הווידאו ומנסה למחוק את
lecture.mp4. - File Explorer מודיע שהקובץ פתוח בתוכנה אחרת, ומציין את הנגן.
- בלשונית Details של Task Manager רון מוצא את
mediaplayer.exeעדיין רץ, בלי שום חלון. - הוא מסיים את התהליך. 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:
#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:
- עוברים ללשונית Details.
- לחיצה ימנית על אחת מכותרות העמודות, Select columns, ומסמנים Handles.
- חוזרים להסתכל על הערכים כמה פעמים לאורך שעות או ימים.
- תהליך שהמספר שלו רק עולה ואף פעם לא יורד הוא החשוד.
| מה בודקים | מתאים לדליפת Handles? |
|---|---|
| לשונית Users | לא. היא מסכמת צריכה לפי משתמש ואינה סופרת Handles |
| Commit size | לא. היא מודדת זיכרון שהוקצה |
| CPU time | לא. הוא מצטבר אצל כל תהליך שעובד, דולף או לא |
| עמודת Handles בלשונית Details | כן, זה בדיוק התפקיד שלה |
ומה Task Manager לא יגיד לכם? הוא נותן מספר, וזהו. אילו אובייקטים עומדים מאחורי 37,000 ה-Handles, ואיך סוגרים אחד מהם, תמצאו רק בכלים שבחלק הבא.
תרחיש 15: סוכן עדכונים שמדליף
| מדידה | Handles של updater.exe | Handles של svchost.exe (אחד מהם) |
|---|---|---|
| יום ראשון בבוקר | 620 | 1,480 |
| יום שלישי | 9,870 | 1,510 |
| יום שבת | 37,300 | 1,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 של תהליך אחר מסוכנת, וכדאי לראות למה, צעד אחר צעד:
- בוחרים Close Handle. Process Explorer עוצר ומזהיר שהפעולה עלולה לערער את התהליך או לאבד נתונים. בלי אישור לא קורה דבר.
- מאשרים. הרשומה נמחקת מהטבלה של התהליך, ואף אחד לא מודיע לו.
- התהליך ממשיך בעבודתו, ובקריאה הבאה עם אותו ערך מקבל שגיאת Handle לא תקף.
- תוכנה שלא צפתה את זה עלולה ליפול, או להשאיר אחריה קובץ שנכתב רק בחלקו.
| מה סגירת Handle בודד לא עושה | בפועל |
|---|---|
| לא פוגעת בתהליכים אחרים | ה-Handle היה רשום רק בטבלה של תהליך אחד |
| לא מסיימת את התהליך, כמו Kill Process | התהליך ממשיך לרוץ בלי ה-Handle |
| לא מפעילה את התהליך מחדש ולא שומרת את הנתונים שלו | הכלי רק מוחק רשומה אחת |
| לא גורמת ל-Windows לפתוח את ה-Handle מחדש | הוא נעלם, עד שהתוכנה עצמה תפתח חדש |
וגם כמה כלים שלא יעזרו כאן:
- Event Viewer: כברירת מחדל הוא לא מתעד איזה תהליך פתח כל קובץ.
- Device Manager: עוסק בהתקני חומרה ובדרייברים.
- Disk Cleanup: מוחק קבצים זמניים, ולא נוגע ב-Handles.
- עריכה ב-Registry: אין שם רשומה שמחזיקה Handle פתוח.
- הפעלה מחדש של explorer.exe: סוגרת רק את ה-Handles ש-explorer.exe עצמו החזיק, ולא את אלה של תוכנות אחרות.
- שינוי עדיפות של Handle: אין דבר כזה. עדיפות היא תכונה של תהליכים ושל Threads.
תרחיש 16: קובץ נתונים שלא נותן למחוק אותו
- אי אפשר למחוק את
dataset_2025.parquet, ואין שום חלון פתוח שקשור אליו. - ב-Process Explorer: Find, Find Handle or DLL, ומקלידים
dataset_2025. - התוצאה:
python.exeעם PID 3384 מחזיק Handle מסוג File לקובץ. - האפשרות הבטוחה: לסיים את
python.exe. Windows תסגור את כל ה-Handles שלו, והמחיקה תעבור. - האפשרות המסוכנת: 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 רגילים:
#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=020 החלונות הוסיפו 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.exe | Service Control Manager: הפעלה וניהול של שירותי הרקע | לא |
| taskmgr.exe | Task 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 שלא נפתח
- תפריט Start ושורת המשימות לא מגיבים ללחיצות, אבל נגן המוזיקה ממשיך לנגן ועורך הטקסט מקבל הקלדה.
- Ctrl+Shift+Esc פותח את Task Manager. בלשונית Processes מסמנים Windows Explorer ולוחצים Restart.
- לרגע אין על המסך אייקונים ולא שורת משימות, ומיד הם מופיעים שוב ומגיבים.
- הנגן והעורך לא הושפעו, כי הם תהליכים נפרדים.
טעויות נפוצות
- סיום 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 פשוט מציג את התוכן שלה על הרקע.
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:
#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 אחד:
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 notify | Secure 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 | Session 0 | |
|---|---|---|
| מה זה | Desktop בשם Winlogon, בתוך WinSta0 של המשתמש | ה-Session שבו רצים שירותי המערכת, מבודד מה-Session של המשתמש החל מ-Windows Vista |
| הקשר ל-UAC | מציג את בקשת האישור | אין: הבקשה לא מוצגת שם, והתוכנה שביקשה הרשאות לא עוברת לרוץ שם |
תרחיש 19: ניסיון לאשר UAC בלי המשתמש
- סקריפט זדוני שרץ בחשבון של אבי מפעיל תוכנית שדורשת הרשאות מנהל.
- UAC מוגדר לרמת ברירת המחדל, ולכן חלון האישור עולה על ה-Secure Desktop.
- הסקריפט מייצר הקשת Enter ולחיצת עכבר, אבל הן נשארות ב-Desktop הרגיל שבו הוא רץ, ולא מגיעות לחלון האישור.
- רק אבי, מול המקלדת והעכבר האמיתיים, יכול לאשר או לסרב.
- אילו 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 settings | mkdir יוצר תיקייה, מפתח 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. כולם באותה מערכת, תחת אותו משתמש ועל אותה חומרה.