Threadsחוטים

טכניקת תכנות שבו- יישום אחד ממומש ע"י

מספר תוכניות Multiעצמאיות נקרא

Programming. יש מספר סיבות-

לממש יישום ככה:מידור.1 לפעמים נוח לתכנת.2

ככה )סוג של שבירתהמטלה(.

היום גם יכול להיות.3 שפעולות מסוימות

יתבצעו במקביל הודות לליבות כפולות וריבוי

מעבדים. לפעמים )בתכנות.4

מדעי( ניתן להפעיל מספר גישות לפתרון

לבעיה קשה.

לפעמים יישום.5 מבצע מספר גדול של פעולות קטנות

ולפעמים נוח לתכנת את הפעולות הללו

כתוכניות עצמאיות.

בעיקרו של דבר של דבר,multi-programmingניתן

אפשרויות:2לממש ע"י .processריבוי תהליכים

.threadsריבוי חוטים

תהליך הוא אמצעי של הרצת תוכניות עצמאיותברמת מערכת ההפעלה.

Threadהוא אמצעי שבו תהליך בודד של מערכת ההפעלה מתחלק לתתי

תוכניות עצמאיות. –ים באThreadממימוש

בשני רמות:-System Thread–

התמיכה בריבוי תוכניות נתמך ברמת

מערכת ההפעלה.

-User End Threads– הניהול של תתי התוכניות נעשה

ביישום עצמו בדרך כלל בסיוע מערכת

ההפעלה בכל הקשורלמדידות זמן וכו'.

-Threadשאלה: למה יש ים?

אנחנו היום עובדים במערכות הפעלה

מוגנות, שבין השאר מגינות על תהליכים זה

מזה. למה לא לעבוד ברמת

התהליכים? תשובה: תהליכים הם משאב של המערכת, הכמות עשויה להיות

מוגבלת,

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

תהליכים הוא דבר יקר. תהליך הוא משאב יחסית

.CPUיקר בזמן -ים נחשבThreadמערכת

בעיני המערכת לתהליך ביןאין מידור, ולכן אחד

מרחב-ים: Threadה- הכתובות של כולם

.משותף

השדותJavaלדוגמא, ב- הסטטיים של התוכנית

.Threadמשותפים לכל ה- מחייבתThreadיצירת

פחות פעולות מיצירתתהליך.

לפעמים יש פחות הגבלות על יצירת

Thread.ים- יצירת תהליך הוא מהלך

די תלוי במערכתההפעלה.

-ים ב-Threadתמיכה ב-Javaמאפשר מימוש קוד

בלי תלוי במערכתההפעלה.

Threadהעברת מידע בין –ים הוא דרך שטחי

זיכרון מה שיוותר מורכבזה הסנכרון ביניהם.

:Threadמהלך חייו של newנולד במצב -

startכאשר עושים - )רוצהrunnableעובר ל-

לרוץ(אחרי שעובר ל--

runnable Threadעשוי לעבור

wait. למצב המתנה 1ביוזמתו לזמן לא מוגבל

למצב המתנה.2 ביוזמתו לזמן מוגבל

timed wait

למצב חסימה אם.3 ניסה לגשת למשאב

blockedנעול למצב סיום.4

Terminated.

http://math.haifa.ac.il/ronn/realtime/docs/

הקבצים הרלוונטיים הםPart7.doc

Part7c.docעד Threadדרך פשוטה יחסית ליצירת

שמספיקה לתרגיל הבית הואכלהלן:

"תוכניתJavaבכדי ליצור ב- עצמאית" הוא צריך להיות יורש

של מחלקה מסוימות או ממשקים מסוימים, הכי פשוט להגדיר אותו

יורש של המחלקה המובניתThread.השורה

class Pthread1 extends Thread

יכולPthread1גורם לכך מופע של למעשה תוכניתThreadלהיות

עצמאית.זה אומר שאם אני אעשה משהו כמו

Pthread1 p1 = new Pthread().

p1.start();

אני מריץ את התוכנית העצמאית. של מחלקה שהיאמופעהקצאת

לא גורמת לו לרוץ.Threadיורשת של מבצעיםהמופעהוא רץ כאשר על

היא מתחילה לרוץ.startמתודה

Java ב-Thread של ה- הקוד הביצועי.run() voidהוא המתודה

סיכום: לעשותאפשר Threadיצירת

ע"י: הגדרת מחלקה חדשה.1

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

ע"י מימוש מתודהThreadה-public void run()

בתוכנית הראשית להקצות.3 מופע של המחלקה ולבצע

)(.startעל המופע

-ים הואThreadיישום מרובה בעייתי מכמה סיבות.

אחד מהם הוא הצורך בסנכרון.http://math.haifa.ac.il/ronn/java/wordfiles/

http://math.haifa.ac.il/ronn/realtime/docs/

–יםThreadאפשרויות ליצירת :1שיטה

המינימום הוא לממש מחלקה- שמממשת את הממשק המובנה בשפה

Runnable. לספקrunחייבים לדרוס את המתודה -

תוכנית ביצועית.

:2שיטה

Executerלהגדיר מחלקה שמממשת את - threadיעיל יחסת כאשר מקצים הרבה -

–ים לפעולות קטנות. בשיטה הזו נשמרים המשאבים של-

thread.שסיים להקצאה חדשה בהמשך מאפשר מימוש מה שנקרא מאגר-

thread ים– thread pool.

-ים, ע"י פקודה threadמקצים מאגר של -ExecuteService משתנה = Exceutors.newCachedThreadPool();

-ים עדיין כמו קודם,threadהקוד של ה--Runnableמיישמים של

newעדיין מקצים את המופעים ע"י - execute-ים ע"י threadמפעלים את ה--

-ים.thread( של מאגר ה-start)במקום

(מצביע לחוט)execute.משתנה

במקום

;()start.מצביע לחוט

-ים, הקוד של ה-threadבתוכנית מרובת -main-נחשב בעצמו ל thread.

-Threadהעברת מידע בין ים היא עניין פשוט ע"י

שימוש או במשתנים סטטיים,- הקצאה דינמית של-

שטח המשמש-Threadלתקשורת בין

ים והעברת כתובת

-Threadהשטח לידי ה-ים המעורבים.

עדיין יש בעיה של סנכרון-ים.Threadאו תאום

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

יתבצעו בסדר מסוים.

לפעמים חלק מה-Threadים לא יכולים-

להמשיך )אין להם מהלעשות( עד שאחד ה-

Threadים יעשה פעולה– מסוימת.

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

.Mutual Exclusion הדדיתמניעה הדדית פירושו ש-

Threadניגש למשאב משותף רק כאשר הוא

אולפני שינוי קרי: תקין

לאחר השלמתלחלוטין שינוי.

הבעיה נובעת מכך ,מכסות זמןשבמסגרת

Thread בכללהיעצר יכול נקודה בכל רגע. מקור הבעיה היא

תוך כדיthreadבעצירת שינוי משאב גלובלי.

פתרון אפשרי הוא מנגנון:נעילות

thread משאבנועל משותף לפני השינוי, וכל

thread לגשת המנסה .נעצרלמשאב הנעול –

הנועלthreadכאשר ה- את המשאב,משחרר מבין הממתיניםהראשון

משתחרר וחוזר חלילה. מנגנון נעילות הוא מנגנון רצוני שאינו מונע עצירה

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

.Objectבמחלקה

–synchronizedמתודה ראשון קוראthreadאם

למתודה על מופע מסוים– הוא נועל את המתודה.

התודה משתחררת רק כאשר הוא יוצא

מהמתודה. נעצרthreadאם ה-

באמצע – המתודה עלהמופע נשארת נעולה.

אם בזמן שהמתודה על המופע נשארת נעולה

threadהיא נקראת ע"י

האחרthreadאחר ה-.ייעצר

נעילה על מופע )בניקודלנעילה על מתודה(:

class A

{

}

A a = new A();

synchronized (a)

{

בזמן שנמצאים פה, .המופע מצביע עליו נעולa ש-

}