שלום, הייתי רוצה באופן כללי להבין מה קורה שתכנית Javascript/PHP או אם מדובר באותו התהליך בכל שפות התיכנות איך המעבד מבצע את התכנית, איך הוא "מעבד" את הפקודות(statements ) והפונקציות של התוכנית(במקרה של JS של הסקריפט) בזו אחרי זו. ובכלל איך מחשב באופן כללי עושה את העבודה הזו, מה קודם למה, איך זה מתאפשר, איך זה משתלב עם העבודה השוטפת של הרצת תוכנות אחרות "רגילות" במחשב בו זמנית, מה סדר העדיפויות ואיך הוא מתקדם בביצוע התוכנית. אשמח גם אפשר להפנות אותי למקורות מידע בנושא (אנגלית או עברית זה לא משנה או ספר גם) שמסבירים את הנושא לעומק ואיך קוראים לנושא הזה שמסביר את התהליך הזה שמבצע המחשב. תודה רבה.

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

http://books.google.com/books?id=1lD9LZRcIZ8C&printsec=frontcover&dq=Computer+Organization+and+Design&hl=iw&cd=1#v=onepage&q&f=false

תודה לgoogle Books

תודה לשניכם, יש אולי משהו יותר מרוכז מזה:

http://books.google.com/books?id=1lD9LZRcIZ8C&printsec=frontcover&dq=Computer+Organization+and+Design&hl=iw&cd=1#v=onepage&q&f=false

אני לא בטוח שאסמבלי זה מה שאני צריך אני לא רוצה לדעת לכתוב פקודות שיפנו למעבד עצמו או לכתוב תוכניות בשפת אסמבלר אני רק רוצה להבין את כל התהליכים שמתבצעים כאשר מחשב מריץ תוכנית JS או PHP לדוגמה איך הוא עובר מפקודה לפקודה, הוא איך הוא מתייחס לפונקציות, איך הוא מתייחס ל-statements, איך הוא "מעבד" פקודות(statements), הבנתי שזה משהו שקשור ל-input queue שבו הוא מאכסן את כל הדברים שהוא צריך לבצע בכלל בכל התוכנות שעובדות או שהמחשב מריץ או יריץ וכאשר הוא מסיים עם פקודה מסוימים או פעולה מסוימת שהוא צריך לבצע הוא מוציא אותה מתוך ה-queue התור ופקודות חדשות נכנסות לסוף של התור. אשמח למשהו יותר ספציפי. תודה.

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

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

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

1. אסמבלי / שפת מכונה

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

2. שפות עילית שעוברות קומפילציה לאסמבלי, כגון C ו-++C

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

3. שפות עילית שעוברות קומפילציה לשפת ביניים, ורצות על Virtual Machine

שפות כמו #C ו-Java לא מתקמפלות ישירות לשפת מכונה, אלא ל"שפת ביניים" (Intermediate Language). תוכנה מיוחדת שמותקנת על המחשב (במקרה של ג'אווה זה ה-JVM, במקרה של #C זה ה-net framework.) בעצם מדמה את הפעולה של המעבד, ומבצעת את הפקודות של שפת הביניים בזו אחר זו. יש כמובן כל מיני דרכים שגורמות לזה להיות יעיל יותר.

4. שפות סקריפטינג ואינטרפרטר, כגון PHP/JS/Python

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

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

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

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

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

התשובה שקיבלתי לזה, עוד פעם כל עוד זה בסדר לשאול כאן:

A computer processor can only execute a set number of commands at the same time. For most computers in the past that was one instruction at a time, now it is common to find processors that can process two or sometimes even more things at the same time.

Basically when the computer is performing tasks it has an input queue of instructions that are waiting to be processed and as it finishes processing each instruction iit then gets the next one off the queue. If you tell the computer to run something right now then that instruction gets added to the end of the queue and will wait its turn to run after anything else already in the queue. When a timeout timer finishes counting down to zero it adds the code it has been told to run onto the end of the queue no differently than any other code that is supposed to run right now and the commands will get run when the processor gets to them.

One thing you need to remember is that ALL of the programs running on your computer are adding commands to be run onto the queue all the time and so how soon after you tell something to run that it actually does will depend on how much is on the queue at that time.

Every time you start something asynchronously such as through a timeout or ajax call in JavaScript you add additional tasks to what is running that will eventually add more commands to the queue.

The more you have running at the time the longer the wait for something that is to run right now before it actually gets to run. There have to be a huge number of things going on before the delay becomes long enough for you to notice.

The only exception to new processes getting added to the end of the queue are a special category of tasks called interrupts. Those are generally sent by separate devices where there is something that needs to be copied into memory right now or it will be lost and so the instruction to do the copy gets to jump the queue. You get to see a list of devices in your computer that are connected to interrupts when you first turn the computer on.

Basically there is no difference between running a command immediately in JavaScript and running it when the timeout finishes counting down. In both cases the command is added to the queue and runs when everything in front of it has run.

Where this delay can make a difference is where you are trying to time a process using timeouts where the commands to be run start another countdown to run the same thing again. Then you have count down to zero followed by time on the queue waiting to run followed by countdown to zero followed by etc..... So each time around takes slightly longer than the countdown would indicate. One way around that is to use setInterval instead of setTimeout because setInterval never stops counting down, it restarts automatically as soon as it reaches zero. So if you were going to use one of these commands to set up an analog clock then using setTimeout would result in the clock gradually falling further behind in when it is supposed to move the hands whereas setInterval would stay roughly the same amount behind all the time.

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

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

המחשב שלך מבצע הרבה פעולות במקביל באמצעות ריבוי תהליכים (process) ונימים (thread).

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

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

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

נ.ב. ייתכן שספציפית ב-javascript העסק עובד קצת שונה ממה שתיארתי לעיל, ולמעשה הקוד שרץ ב-setTimeout לא ירוץ במקביל לקוד אחר בדף... קצת קשה לי לומר כי אני לא מכיר את העסק ב-JS ספציפית.

תודה רבה על ההסבר אבל עד כמה שאני יודע אין ב-JS אפשרות לשתי פונקציות להתבצע במקביל, בכל מקרה אם מישהו שיותר מכיר ספציפית את JS יודע מה יקרה במצב כזה האם הקוד שנמצא בתוך ה-setTimeout ירוץ מיד כשהטיימר מסתיים או שאם יש פונקציה אחרת שרצה באותו הזמן שהטיימר מגיע ל-0, הוא יחכה שהיא תסיים לרוץ ואז הקוד שנמצא בתוך ה-setTimeout יתבצע?

גם לא הבנתי בדברים שהוא כתב(מה שהעתקתי משם שרשום באנגלית) איך זה בדיוק עובד ה-input queue? , כל פקודה statement בתוכנית מוכנסת לסוף ה-queue ומתבצעת רק שאין פקודות או משימות אחרות(בכלל במחשב) לפנייה אבל למעשה כל פקודה בתוכנית מתבצעת במליונית שנייה או משהו כזה? ואיך זה עובד עם פונקציות(פונקציות רגילות)? כל הפונקציה מוכנסת לתוך ה-queue או כל statement בפונקציה מוכנס אחד אחרי השני(ואז בעצם אין ממש הבדל בין זה לבין רשימה של statements אחד אחרי השני שלא נמצאים בתוך פונקציה מוגדרת שמתבצעת)? כל התיאוריה הזאת עם ה-queue זה דבר נפוץ לתאר את הפעולות והתהליכים במחשב ובפרט פקודות statements של תוכנית בעזרתו? כי אחרי בסופו של דבר התוכנית מתבצעת פקודה אחרי פקודה ולא "מרגישים" זמן המתנה בין פקודה לפקודה (אלא אם כן מדובר בפקודה בתוך setTimeout ואז זו המטרה בעצם להשהות את הביצוע של פקודה) ואם יש קריאה לפונקציה אז הפונקציה מתבצעת פקודה אחרי פקודה ובסוף הביצוע חוזר לנקודה בה הפונקציה נקראה. אם מישהו יוכל בבקשה להסביר את זה כי לא כל כך הבנתי איך זה עובד. תודה רבה.

תודה רבה על ההסבר אבל עד כמה שאני יודע אין ב-JS אפשרות לשתי פונקציות להתבצע במקביל, בכל מקרה אם מישהו שיותר מכיר ספציפית את JS יודע מה יקרה במצב כזה האם הקוד שנמצא בתוך ה-setTimeout ירוץ מיד כשהטיימר מסתיים או שאם יש פונקציה אחרת שרצה באותו הזמן שהטיימר מגיע ל-0, הוא יחכה שהיא תסיים לרוץ ואז הקוד שנמצא בתוך ה-setTimeout יתבצע?

לא יודע, זה תלוי בהגדרות של JS.

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

לא יודע, זה תלוי בהגדרות של JS.

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

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

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

מה בעצם נכנס לתוך התור? כל הפקודות statements של התוכנית ותוכנות ומשימות אחרות של המחשב שנקראות ומתווספות לסוף התור ומתבצעות רק אחרי שכל הפקודות/המשימות האחרות שנמצאות כבר בתור לפניהן מתבצעות? (ד"א למה במה שהוא כתב הוא השתמש במושג command ו- instruction מה ההבדל בין שני הדברים? ו-statement זה עוד דבר ששונה משניהם?)

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

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

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

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

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

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

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

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

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

תהליך הוא בעצם תוכנה?

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

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

המערכת הפעלה בעצם מזגזגת בין כל התהליכים שפועלים ברקע?

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

משפיעות על הביצוע של התוכנית של ה-JS שגם היא תהליך של הדפדפן (רק שהזיגזוג הזה קורא כל הזמן מהר ולא לפי "דרישה" בעצם)?

ולא הבנתי שרשמת

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

מה הכוונה לטפל בשני אירועים במקביל? תודה רבה.

תהליך הוא בעצם תוכנה?

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

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

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

המערכת הפעלה בעצם מזגזגת בין כל התהליכים שפועלים ברקע?

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

ולא הבנתי שרשמתמה הכוונה לטפל בשני אירועים במקביל? תודה רבה.

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

תודה רבה על העזרה, יש לי עוד כמה שאלות:

מבחינת המודל כשלעצמו של ה-treads וה-processes הוא מודל של המערכת ההפעלה שחל בעצם כל על תוכנות/אפליקציות של כל שפת תיכנות (JS,C,C++,JAVA,PHP וכו')? או בעצם יכול להיות שהוא לא חל נגיד על JS (אני שואל כי רשמת שיכול להיות שב-JS זה קצת שונה)?

מבחינת המודל הזה של ה-threads וה-processes מה התייחסות לתוכנית JS ,נגיד זה לא נחשב ממש לתוכנה(נגיד כמו משהו שהיינו רושמים ב-C או ב-JAVA) זה יותר סקרפיט אבל סוג של אפליקציה שבעצם פועלת בתוך דף אינטרנט שהוא מוצג ע"י תוכנה - הדפדפן, אז בעצם הדפדפן הוא תהליך כי הוא תוכנה אבל מה זה אומר על תוכנית ב-JS היא תהליך גם כן ? ואם כן בעצם הדפדפן הוא thread? אם אתה יוצר כמה תוכניות ב-javascript כל אחת מהן היא תהליך? ואם נגיד אתה יוצר בתוך תוכנית javascript קריאה ל-setTimeout אז העובדה שהתוכנית JS עוקבת אחרי הטיימר ובודקת אותו תוך כדיי ביצוע התוכנית ובסוף מבצעת את הקוד שנמצא בו בשלב מסוים(אחרי הפונקציה האחרת נגיד אם הטיימר מגיע ל-0 כשהביצוע של הקוד כרגע בתוך פונקציה) אז זה הופך את התוכנית הזאת ל-thread? העובדה שהקוד של הטיימר רץ, נגיד וזה המקרה, אחרי הפונקציה ולא בו זמנית זה זה אומר בעצם שאין כאן זיגזוג או שיש בכל זאת? כדאי שיהיה זיגזוג חייב נגיד שהפקודה של הטיימר (אחרי שהטיימר סיים) והקוד שרץ שכרגע יבוצעו בו זמנית במקביל?

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

פונקציות שהם asynchronous הם בעצם פונקציות שיוצרות בתכנית זיגזוג והופכות אותו ל-thread?

יכול להיות שהתור שהזכרת זה בעצם אותו התור שהמשתמש האחר הזכיר בהודעה שהעתקתי משם באנגלית(אני פשוט מנסה לחשוב למה הוא יכל להתכוון)? כי לפי מה שהבנתי זה מהסבר שלו והסבר שלך התיפקוד קצת דומה כאילו שכל פעם כשיש תהליך שמריצים אותו המערכת הפעלה מכניסה אותו לסוף התור ובנוסף יש בתור תהליכים של המערכת הפעלה עצמה שהיא מוסיפה לתור ויש תהליכים שיכולים לקפוץ ישר לראש התור( נראה לי הוא קרה לזה שם Interrupts) ויש תהליכים שרצים ברקע שגם משפיעים?

ועוד שאלה במודל הזה של ה-threads וה-processes מעורב בעיקר המעבד או גם הזיכרון של המחשב איך זה בדיוק עובד מהבחינה הזאת?

תודה רבה.