Az előadás letöltése folymat van. Kérjük, várjon

Az előadás letöltése folymat van. Kérjük, várjon

Krizsán Zoltán.  Ha az algoritmus sokáig dolgozik,  de el akarjuk kerülni a „fagyást”.  Kisebb a költsége, mint az új folyamatnak.  Programozás szempontjából.

Hasonló előadás


Az előadások a következő témára: "Krizsán Zoltán.  Ha az algoritmus sokáig dolgozik,  de el akarjuk kerülni a „fagyást”.  Kisebb a költsége, mint az új folyamatnak.  Programozás szempontjából."— Előadás másolata:

1 Krizsán Zoltán

2  Ha az algoritmus sokáig dolgozik,  de el akarjuk kerülni a „fagyást”.  Kisebb a költsége, mint az új folyamatnak.  Programozás szempontjából is könnyebb, mint az IPC (fájl, osztott memória, …)

3  Létrehoz,  elindít szálat

4  IsAlive Gets a value indicating that the current thread is currently executing.  IsBackground Gets or sets whether the thread runs as a background thread.  IsThreadPoolThread Gets whether this thread is a thread in the thread pool.  ManagedThreadId Gets a number to identify the current thread. Not the same as the operating system’s thread ID.  Name Gets or sets a name associated with the thread.  Priority Gets or sets the priority of the thread.  ThreadState Gets the ThreadState value for the thread.

5  Abort Raises a ThreadAbortException on the thread to indicate that the thread should be aborted.  Interrupt Raises a ThreadInterruptedException when a thread is in a blocked state (ThreadState.WaitSleepJoin). If the thread never blocks, the interruption never happens.  Join Blocks the calling thread until the thread terminates.  Resume Deprecated. Do not use.  Start Sets a thread to be scheduled for execution.  Suspend Deprecated. Do not use.

6 1. Definiáljunk egy metódust! (nincs vé, nincs paraméter) 2. Hozzunk létre egy ThreadStart delegátum példányt! 3. Hozzunk létre egy új Thread példányt megadva az előző delegátumot! 4. Hívjuk meg a start metódust! (A fonálba fut a 1. metódus, majd leáll.)

7 static void SimpleWork() { Console.WriteLine("Thread: {0}", Thread.CurrentThread.ManagedThreadId); } ThreadStart operation = new ThreadStart(SimpleWork); Thread theThread = new Thread(operation); theThread.Start();

8 ThreadStart operation = new ThreadStart(SimpleWork); for (int x = 1; x <= 5; ++x) { Thread theThread = new Thread(operation); theThread.Start(); }

9  Fő fonál (main thread) létrehozza a munka fonalakat (working thread), nyilvántartja azokat, amelyek a kiegészítő munkákat végzik.  Grafikát, vezérlőket csak a fő szálból lehet használni!  Amikor a fő szálnak szüksége van az eredményekre Join minden munka szálra a főszálból!

10  Highest The highest priority  AboveNormal Higher priority than Normal  Normal The default priority  BelowNormal Lower than Normal  Lowest The lowest priority

11  ThreadStart helyett ParameterizedThreadStart delegátum használata.  A paraméter Object típusú, cast-olni kell! (as, is operátor)  A paraméter aktuális értékét a Start metódusnak kell adni! theThread.Start("Hello");

12  Hívjuk a Thread.Abort metódust!  Ennek hatására a szálban a ThreadAbortException kivétel dobódik!  Vagy elkapjuk, vagy nem, de a fonál leáll!

13  Az Abort metódus megszakítja a normál futást, ami következtében inkonzistens lehet az alkalmazásunk.  Ezt elkerülendő használjuk a kritikus szakaszt.  Ezt nem szakíthatja meg a rendszert. Thread.BeginCriticalRegion(); SomeClass.IsValid = true; SomeClass.IsComplete = true; Thread.EndCriticalRegion();

14  Minden szálhoz tartoznak adatok: biztonsági, kultúra, tranzakció  Elérni a ExecutionContext statikus metódusaival lehet azokat.  Egy rendszer szintű szál kezeli ezeket az információkat (teljesítmény szükséglet).  Felfüggesztés : AsyncFlowControl flow = ExecutionContext.SuppressFlow()  Visszaállítás: ExecutionContext.RestoreFlow();

15  Interlocked  lock{}  Mutex  …

16 public class Counter{ public static int Count; static void UpdateCount() { for (int x = 1; x <= 10000; ++x) { Counter.Count = Counter.Count + 1; }

17 ThreadStart starter = new ThreadStart(UpdateCount); Thread[] threads = new Thread[10]; for (int x = 0; x < 10; ++x) { threads[x] = new Thread(starter); threads[x].Start(); } for (int x = 0; x < 10; ++x) { threads[x].Join(); }

18  Hyper-Threading processzoroknál az eredmény nem 100,000  Mert az írás, olvasás nem atomi!  Counter.Count++ művelet: Betöltik a változó értékét egy regiszterbe. Növelik a regiszter értékét. Új érték vissza a változóba.

19 Interlocked osztály használata. static void UpdateCount() { for (int x = 1; x <= 10000; ++x) { Interlocked.Increment(ref Counter.Count); }

20 public void UpdateCount() { Interlocked.Increment(ref _count); if (Count % 2 == 0){ Interlocked.Increment(ref _evenCount); }  Újabb probléma: a 2. számláló rossz lesz  Hiszen ugyanazt a szálat beengedi.  Nem az összetett művelet védett csak a 2 kölün-külön!

21 public void UpdateCount() { lock (this) { _count = _count + 1; if (Count % 2 == 0) // An even number { _evenCount = _evenCount + 1; }

22 public void UpdateCount(){ Monitor.Enter(this); try{ _count = _count + 1; if (Count % 2 == 0) // An even number { _evenCount = _evenCount + 1; } finally{ Monitor.Exit(this); }

23  Több lehetőség adódik a segítségével!  Enter Creates an exclusive lock on a specified object  Exit Releases an exclusive lock on a specified object  TryEnter Attempts to create an exclusive lock on a specified object; optionally supports a timeout value on acquiring the lock  Wait Releases an exclusive lock, and blocks the current thread until it can re-acquire the lock

24  Problémákat old meg, de újat vezet be: holtpont(deadlock)  2 erőforrás (1,2) 2 szál (A,B) A lokkolja 1-est és ugyanekkor B lokkolja 2- est  majd ezután kellene A-nak a 2es és B-nek az 1es  Mivel esek már lokkoltak mindkettő a másik által foglalt erőforrásra vár.

25 class Deadlocker{ object ResourceA = new Object(); object ResourceB = new Object(); } public void First(){ lock (ResourceA){ lock (ResourceB){ Console.WriteLine("First"); } public void First(){ lock (ResourceA){ lock (ResourceB){ Console.WriteLine("First"); } public void Second(){ lock (ResourceB){ lock (ResourceA){ Console.WriteLine("Second"); } public void Second(){ lock (ResourceB){ lock (ResourceA){ Console.WriteLine("Second"); }

26 Deadlocker deadlock = new Deadlocker(); ThreadStart firstStart = new ThreadStart(deadlock.First); ThreadStart secondStart = new ThreadStart(deadlock.Second); Thread first = new Thread(firstStart); Thread second = new Thread(secondStart); first.Start(); second.Start(); first.Join(); second.Join();

27  Monitor.TryEnter egy timeout érték múlva lemond a lokkolási kéréséről és kilép a saját lock-ból.  Csökkentsük a legkisebbre a lokkolt kódot. Csökkent a lokkolási idő, így a holtpont kialakulásának esélye.

28  Különbséget teszt olvasási és írási lock között.  Olvasási beenged többet is, de írásiba csak 1 et.  Ha írják, nem lehet olvasni.  UpgradeToWriterLock, DowngradeFromWriterLock

29 ReaderWriterLock rwLock = new ReaderWriterLock(); int counter = 0; try{ rwLock.AcquireReaderLock(100); rwLock.AcquireWriterLock(1000); try{ Console.WriteLine(counter); Interlocked.Increment(ref counter); } finally{ rwLock.ReleaseReaderLock();} } catch (ApplicationException){ Console.WriteLine("Failed to get a Lock"); }

30 Mutex theMutex = null; try // Try and open the Mutex{ theMutex = Mutex.OpenExisting("MYMUTEX"); } catch (WaitHandleCannotBeOpenedException){ // Cannot open the mutex because it doesn't exist } if (theMutex == null){ theMutex = new Mutex(false, "MYMUTEX"); } //használat if (theMutex.WaitOne(1000, false)) // wait 1 second for lock{ }

31 byte[] buffer = new byte[100]; string filename = string.Concat(Environment.SystemDirectory, "\\mfc71.pdb"); FileStream strm = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read, 1024, FileOptions.Asynchronous); IAsyncResult result = strm.BeginRead(buffer, 0, buffer.Length, null, null); // Közben csinálhatunk bármit int numBytes = strm.EndRead(result); // amikor kell az eredmény strm.Close(); Console.WriteLine("Read {0} Bytes", numBytes); Console.WriteLine(BitConverter.ToString(buffer));


Letölteni ppt "Krizsán Zoltán.  Ha az algoritmus sokáig dolgozik,  de el akarjuk kerülni a „fagyást”.  Kisebb a költsége, mint az új folyamatnak.  Programozás szempontjából."