, תקשורת אסינכרוני תכנות- ל אפליקציות Windowsופיתוח

8.1- ל WindowsואפליקציותPhone 8

Asynchronous programming

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

. , בשני אחד תלויים היו לא שכתבנו התהליכים כל כה עד

. , משותפים במשאבים שימוש עשו לא שכתבנו התהליכים כל כה עד

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

. מסוכנת להיות יכולה כאלו במצבים אסינכרוניות

Thread Synchronization לכולם או לחלקם במקביל תהליכים מספר רצים בתוכנית כאשר

. המשותף למידע גישה יש

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

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

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

:הסכנות. אחר תהליך ידי על שנשמר מידע להרוס יכול תהליך. אחר תהליך ידי על ששונה מידע על להסתמך יכול תהליך יציב לא מידע על להסתמך יכול תהליך

) עבודתו) את להשלים הספיק שהוא לפני הסתיים תהליך

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

X = rnd.Next();Y = rnd.Next();X = rnd.Next();Y = X;

למה?

Thread Synchronizationנפרד: – תהליך ללא א שלב לדוגמה

: דוגמה ThreadProblemקוד

public class SampleClass { private object threadLock = new object(); private int num; private Random rnd = new Random(); public void PrintNumbers() { Console.WriteLine("-> {0} is executing PrintNumbers()", Thread.CurrentThread.Name); Console.Write("Numbers: "); for (int i = 0; i < 10; i++) { Thread.Sleep(100 * rnd.Next(5)); num = i; Console.Write("{0}, ", num); } Console.WriteLine(); } }

static void Main(string[] args) { Thread.CurrentThread.Name = "Main Thread"; SampleClass p = new SampleClass(); //1 - Run method 10 time Console.ForegroundColor = ConsoleColor.Red; for (int i = 0; i < 10; i++) { p.PrintNumbers(); } }

משאב משותף

מתודת עבודה

המשאב שינויהמשותף

הפעלת המתודה

Thread Synchronization: א שלב פלט

Thread Synchronizationנפרד: – בתהליך ב שלב public class SampleClass לדוגמה

{ private object threadLock = new object(); private int num; private Random rnd = new Random(); public void PrintNumbersAsynch () { Console.WriteLine("-> {0} is executing PrintNumbers()", Thread.CurrentThread.Name); Console.Write("Numbers: "); for (int i = 0; i < 10; i++) { Thread.Sleep(100 * rnd.Next(5)); num = i; Console.Write("{0}, ", num); } Console.WriteLine(); } }

משאב משותף

מתודת עבודה

המשאב שינויהמשותף

static void Main(string[] args) { Console.ForegroundColor = ConsoleColor.Green; Thread[] threads_arr1 = new Thread[10]; for (int i = 0; i < 10; i++) { threads_arr1[i] = new Thread (new ThreadStart(p.PrintNumbersAsynch)); threads_arr1[i].Name = string.Format("Worker thread #{0}", i); } foreach (Thread t in threads_arr1) t.Start(); }

הפעלת המתודה

יצירת תהליכים

Thread Synchronization: ב שלב פלט

Thread Synchronization

. בעיה פה שיש ברור

ברור לא משהו היא והתוצאה שרצים התהליכים לכל המשותף ערך להדפיס מבקש תהליך כל. יציב ולא

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

. אסינכרוניים הם מטבעם הם תהליכים

, השמות מרחב הרב להכניס System.Threadingלמזלנו המאפשרות גישות כמה מממש. האסינכרוני בכאוס סינכרוני סדר

Thread SynchronizationBlocking

נקראת לסינכרון ביותר הפשוטה .Simple Blockingאו Blockingהשיטה

( חסימה של במצב נמצא :Blockingתהליך מקרים( בשני המתודה .Thread.Sleepהפעלת מוגדר)…( – זמן לפרק התהליך חסימת המתודה .Thread.Joinהפעלת אחר)( - תהליך של לסיומו עד הנוכחי התהליך חסימת

, הקצאת מקבל לא הוא חסום במצב נמצא שתהליך CPU. static void Main(string[] args)בזמן { Thread thread = new Thread(DoSomething); thread.Start(); Console.WriteLine(thread.ThreadState); thread.Join(); Console.WriteLine(thread.ThreadState); Console.WriteLine("Application Ended successfully"); }

public static void DoSomething() { int counter=0; while (counter<10) { Thread.Sleep(2000); Console.WriteLine(DateTime.Now.ToLongTimeString()); counter++; } }

Blocking שניות 2של

עד ממתין הראשי התהליךהתהליך של threadלסיומו

: דוגמה ThreadBlockingקוד

static decimal num1 = 1;static decimal num2 = 1;static Random rnd = new Random();static void WorkerThread1(){ var watch = Stopwatch.StartNew(); num1 = Fibonacci(rnd.Next(10,30)); watch.Stop(); Console.WriteLine("From WorkerThread1 : num1 = " + num1 + " , Working time: " + watch.ElapsedMilliseconds + " ms");}static void WorkerThread2(){ var watch = Stopwatch.StartNew(); num2=Fibonacci(rnd.Next(10,30)); watch.Stop(); Console.WriteLine("From WorkerThread2 : num2 = " + num2 + " , Working time: " + watch.ElapsedMilliseconds + " ms");}

Thread SynchronizationJoin – נוספת דוגמה

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

: דוגמה ThreadJoinSampleקוד

Thread SynchronizationJoin) המשך – ) נוספת דוגמה

static void Main(string[] args) { Thread t1 = new Thread(new ThreadStart(WorkerThread1)); t1.Start();

Thread t2 = new Thread(new ThreadStart(WorkerThread2)); t2.Start();

t1.Join(); t2.Join(); Console.WriteLine(num1 + num2);

}

לסיום המתנהשני

התהליכים

התלוי חישובשני בתוצאת

התהליכים

: דוגמה ThreadJoinSampleקוד

Thread SynchronizationCritical Section

( קריטי התערבות( Critical Sectionמקטע ללא להתבצע שצריך קוד מקטע הוא. / משותף משאב של ביניים תוצאות תוצאות על להשפיע שעלול אחר תהליך של חיצונית

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

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

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

: בעייתית לא דוגמה

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

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

Thread SynchronizationCritical Section

: הבא הקוד של הפלט יהיה מה

class Program{ static void Main(string[] args) { Sample sample = new Sample(); Thread thread = new Thread(sample.DoTask1); thread.Start(); sample.DoTask1(); }}class Sample{ private bool flag; public void DoTask1() { if (!flag) { flag = true; Console.WriteLine("Done - " + Thread.CurrentThread.Name); } }} : קוד CriticalSectionProblem01דוגמת

Thread Synchronizationלמה?

: קוד CriticalSectionProblem01דוגמת

Thread Synchronization

: הבא הקוד של הפלט יהיה ומה

class Program{ static void Main(string[] args) { Sample sample = new Sample(); Thread thread = new Thread(sample.DoTask2); thread.Start(); sample.DoTask2(); }}class Sample{ private bool flag; public void DoTask2() { if (!flag) { Console.WriteLine("Done"); flag = true; } }}

: קוד CriticalSectionProblem01דוגמת

Thread Synchronization?למה

Thread Synchronization

: הבא מהקוד להיגרם העלולה הסכנה מה

class Program { static void Main(string[] args) { ThreadUnsafe sample = new ThreadUnsafe(); Thread thread = new Thread(sample.DoTask); thread.Start(); sample.DoTask(); } } class ThreadUnsafe { private int num1=10, num2=5; public void DoTask() { if (num2 != 0) { Console.WriteLine(num1 / num2); } num2 = 0; } } : קוד CriticalSectionProblem02דוגמת

Thread Synchronization: מסוכן הוא הבא הקוד קטע

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

( " קריטי " מקטע נקרא (.Critical Sectionהוא

. יותר או תהליכים שני ידי על משותף במשאב משימוש נובע הוא

. " בלעדי" שימוש שיבטיח סנכרון מנגנון דורש קריטי מקטע

public void DoTask() { if (num2 != 0) { Console.WriteLine(num1 / num2); } num2 = 0; }

Thread SynchronizationLock

למקטעים ביותר הפשוט נעילה מנגנוןקריטיים.

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

. בעת בו הקריטי

? למה: הפלט

class Program { static void Main(string[] args) { ThreadUnsafe sample = new ThreadUnsafe(); Thread thread = new Thread(sample.DoTask); thread.Start(); sample.DoTask(); } } class ThreadSafe { private int num1=10, num2=5; private object lockThis = new object(); public void DoTask() { lock (lockThis) { if (num2 != 0) { Console.WriteLine(num1 / num2); } num2 = 0; } } }

נעילה

אובייקט נעיל/ הסנכרון

ה

: קוד LockSample01דוגמת

Thread Synchronization. אחד תהליך ידי על רק להינעל יכול הסנכרון אובייקט זמנית בו

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

. משותפים – משאבים על שמירה ברור היתרון

? ? המסקנה מה החיסרון lock (lockThis)מה{ if (num2 != 0) { Console.WriteLine(num1 / num2); } num2 = 0;}

: קוד LockSample01דוגמת

Thread SynchronizationLock. סינכרון אובייקט מקבל

להיות יכול הסנכרון .thisאובייקט

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

. לנעילה בו להשתמש

של למצב להוביל שעלול .DeadLockמה

( מקטעים שני ומיותרת מרגיזה איטיות של למצב להוביל שעלול מה.) ננעלים משאבים משתפים שאינם

: פרטי בשדה שימוש הפיתרון

private object lockThis = new object;)(

של הקלעים המחלקה lockמאחורי .Monitorמסתתרת

lock (lockThis){ if (num2 != 0) { Console.WriteLine(num1 / num2); } num2 = 0;}

: קוד LockSample01דוגמת

Thread Synchronization - ה את להכיר ?Worker Threadמבלי נעילה , מתבצעת היכן

' א 'אפשרות ב אפשרות

Thread Synchronization

. מתודות שתי על מתבצעת הנעילה הפעם

באמצעות שננעל מאפשר lockאובייקט אינואפילו או אחרת מתודה על מדובר גם גישה

. אחרת מחלקה

public static void DoSomething01() { lock (locker) { for (int i = 0; i < 1000; i++) { Console.ForegroundColor = ConsoleColor.Red; Console.Write("X"); } } } public static void DoSomething02() { lock (locker) { for (int i = 0; i < 1000; i++) { Console.ForegroundColor = ConsoleColor.Green; Console.Write("Y"); } } } : קוד LockSample02דוגמת

Thread SynchronizationDeadlock – שהתהליך בעוד החסימה את שישחרר שני לתהליך ממתין ראשון תהליך

. הראשון בתהליך החסימה לסיום ממתין השני public void Func1() { lock (lock1) { Console.WriteLine("Func1 -> lock1 activated"); Calc1(); } } public void Calc1() { lock (lock2) { Console.WriteLine("Func1 -> lock2 activated"); shared_num++; Console.WriteLine("From Func1: {0})", shared_num); } }

: קוד DeadlockSample01דוגמת

Thread Synchronizationהמשך

public void Func2() { lock (lock2) { Console.WriteLine("Func2 -> lock2 activated"); Calc2(); } } public void Calc2() { lock (lock1) { Console.WriteLine("Func2 -> lock1 activated"); shared_num++; Console.WriteLine("From Func2: {0})", shared_num); } }

: קוד DeadlockSample01דוגמת

Thread Synchronization

? חסימה נבצע מתיבלוק ואשר lockבתוך יותר או אחד שדה של ערך משנה אשר קוד מקטע כל נתחום

. תהליכים למספר נגיש

- ב לתחום צורך (.lockאין מזיק ) אפילו ערכים קוראים שרק מקטעים

Lock , רק לוקח מאוד מהיר .20ns (Nano Seconds)הוא

Thread SynchronizationMonitor

השמורה " lockהמילה למחלקה קיצור כ סה .Monitorהיא

-intכמו .Int32ו

- ל -Monitor.Exitקריאה ל לקרוא .Monitor.Enterמבלי חריגה תעורר

class ThreadSafe { private int num1 = 10, num2 = 5; private object locker = new object(); public void DoTask() { Monitor.Enter(locker); if (num2 != 0) { Console.WriteLine(num1 / num2); } num2 = 0; Monitor.Exit(locker); } }

: קוד MonitorSampleדוגמת

Thread SynchronizationMutex

כמוlock. הוגדר הוא בה האפליקציה לגבולות מעבר פועל אבל

Mutex הואComputer Wide. , שונות , אפליקציות בין גם חסימות לבצע יודע דהיינו

- ב .IPCשימושי

פי - 50איטי פעולה, lockמ .1msזמן

. בעת – בו לרוץ תוכל אפליקציה של אחד מופע שרק להבטיח מקובל שימוש

Semaphore

. " האסינכרוני" התכנות של הלילה מועדון

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

: קוד MutexSampleדוגמת

: קוד SemaphoreSampleדוגמת

: , , ב להוריד ניתן מצגות חומרים הסילבוס את

. . .www corner co il