, תקשורת אסינכרוני תכנות- ל אפליקציות 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דוגמת
