Haladóprogramozás (C#) BMF NIK Párhuzamos programozás: folyamatok és ak A párhuzamos programozás alapjai A végrehajtás szétválasztása: elszigetelés és párhuzamosítás Párhuzamosság és ütemezés az operációs rendszer szintjén Folyamatok fogalma és kezelése Új folyamat indítása, létező folyamatok leállítása és bevárása Folyamatok tulajdonságainak és eseményeinek kezelése Szálak fogalma és kezelése Új ak indítása, ak felfüggesztése, állapotvezérlése és leállítása, ak prioritási szintjei Előtér- és háttérak, ThreadPool ak, aszinkron metódushívás Szinkronizáció A szinkronizáció alapfogalmai, versenyhelyzet és holtpont fogalma Kölcsönös kizárás biztosítása, a lock utasítás, ak bevárása és randevúja miklos.arpad@nik.bmf.hu Hallgatói tájékoztató A jelen bemutatóban található adatok, tudnivalók és információk a számonkérendő anyag vázlatát képezik. Ismeretük szükséges, de nem elégséges feltétele a sikeres zárthelyinek, illetve vizsgának. Sikeres zárthelyihez, illetve vizsgához a jelen bemutató tartalmán felül a kötelező irodalomként megjelölt anyag, a gyakorlatokon szóban, illetve a táblán átadott tudnivalók ismerete, valamint a gyakorlatokon megoldott példák és az otthoni feldolgozás céljából kiadott feladatok önálló megoldásának képessége is szükséges. A párhuzamos végrehajtás alapjai A Neumann-architektúrára épülőszámítógépek a programokat sorosan hajtják végre A gépi kódúprogramok tényleges futtatása utasításról utasításra történik. Ahhoz, hogy egy számítógépen egyszerre több program is futtathatólegyen, olyan megoldásra van szükség, amely biztosítja a végrehajtás alatt álló programok egymástól való elszigetelését, valamint a végrehajtás alatt álló programok (látszólag) egyidejű futását. A programok elszigetelése és párhuzamosítása a folyamatok koncepciójának segítségével megoldható Az elszigetelés érdekében minden folyamat saját memóriaterülettel rendelkezik, amelyet más folyamatok nem érhetnek el, így hiba esetén csak a hibázófolyamat sérül, a rendszer többi eleme működőképes marad (viszont a folyamatok közötti közvetlen kommunikációra sincs egyszerű lehetőség). A párhuzamosítás tipikus megoldása az időosztás, amikor minden folyamat kap egy-egy ún. időszeletet, melynek leteltét követően egy másik folyamat kapja meg a vezérlést. Ez a megoldás gyakoratilag függetleníti egymástól a processzorok és a rajtuk egyidőben futtatható programok számát.
Illusztráció: az időosztás elve Futó állapot P folyamat Megszakítás vagy rendszerhívás Állapotmentés (PCB ) Állapotbetöltés(PCB ) P folyamat Futásra kész vagy várakozóállapot Futásra kész vagy várakozóállapot Futó állapot Megszakítás vagy rendszerhívás Állapotmentés (PCB ) Állapotbetöltés(PCB ) Futó állapot Futásra kész vagy várakozóállapot Original image 000-00 David A. Solomon and Mark Russinovich Ütemezés az operációs rendszerekben Az ütemezés fogalma a végrehajtás alatt állóprogramok közötti rendszeres váltás módját, időzítését és szabályait takarja A Microsoft Windows preemptív, prioritásos, körbenforgó, kétszintű* ütemezési politikát alkalmaz. Az ütemezés preemptív : az operációs rendszer kívülről bármikor képes megszakítani a programok futását Az ütemezés prioritásos : minden programnak van egy fontossági szintje (prioritása), amely meghatározza, hogy egy-egy időszelet lejártakor melyik program következhet sorra Az ütemezés körbenforgó : az egyforma prioritásúprogramok között a rendszer egyenlően osztja el a rendelkezésre állóidőt, és a programok sorban egymás után kapnak egy-egy időszeletet (az utolsó program időszelete után ismét az első következik) Az ütemezés kétszintű : az elszigetelt folyamatok mellett léteznek ún. ak is, amelyek a futtatni kívánt kód egy folyamaton belüli további bontását teszik lehetővé(lásd később) A Unix/Linux rendszerek a legutóbbi időkig félig preemptív, prioritásos, körbenforgó, egyszintű ütemezési politikát alkalmaztak. Az ütemezés félig preemptív : az operációs rendszer a programok futását kívülről bármikor képes megszakítani, saját belső elemeinek futását azonban nem Az ütemezés egyszintű volt: a rendszerben csak elszigetelt folyamatok léteznek, ezek képezték a párhuzamosítás alapegységét is (a Linux ma már kezelést is támogat) * A modell ténylegesen négyszintű, de a legfelső( job ) és a legalsó( fiber ) szemcsézettségi szint csak speciális módon használható. Folyamatok A.NET keretrendszerben a folyamatok megfelelnek az operációs rendszer folyamatainak A folyamatok kezelését a System.Diagnostics.Processés a System.Diagnostics.ProcessStartInfoosztályok biztosítják. A Process osztály segítségével új folyamatok hozhatók létre, létezőfolyamatok szüntethetők meg és a folyamatokról részletes adatok érhetők el. A ProcessStartInfo osztály segítségével számos paraméter és beállítás adhatómeg a folyamatként elindítani kívánt programokhoz. A.NET a folyamatokon belül egy további szintet, az ún. alkalmazástartományt ( application domain ) is meghatároz A felügyelt kódúprogramokat a keretrendszer futtatás közben is ellenőrzi, ezért ezek nem képesek egymást negatívan befolyásolni. Így viszont nem feltétlenül szükséges külön folyamatként futtatni őket, ami sebesség és memóriaigény szempontjából nagy előny, mivel a folyamatok létrehozása, nyilvántartása és a közöttük történő váltás sok időt és memóriát igényel. Az alkalmazástartományokkal és programozásukkal a jelen tárgy keretében nem foglalkozunk részletesen.
Folyamatok kezelése (kivonatos referencia) System.Diagnostics.Process osztály Metódusok Start() CloseMainWindow() Kill() GetCurrentProcess() GetProcesses() WaitForExit() Tulajdonságok StartInfo PriorityClass EnableRaisingEvents HasExited ExitCode, ExitTime StandardInput, StandardOutput Események Exited Folyamat indítása Folyamat főablakának bezárása (GUI alkalmazásoknál) Folyamat leállítása Aktuális folyamatot reprezentáló objektum lekérése Összes folyamat adatainak lekérése a helyi számítógépről Várakozás az adott folyamat befejeződésére A folyamathoz tartozó ProcessStartInfo példány A folyamat prioritása (fontossági szintje) A folyamat kiválthat-e eseményeket A folyamat kilépett-e Kilépési kód, illetve a kilépés (vagy leállítás) időpontja Alapértelmezett be- és kimeneti csatorna (adatfolyam) A folyamat kilépett (vagy leállították) Folyamatok kezelése (kivonatos referencia) System.Diagnostics.ProcessStartInfo osztály Tulajdonságok FileName Fájlnév megadása az indítandófolyamathoz (program vagy programmal társított fájltípusba tartozó fájl neve) Arguments, WorkingDirectory Parancssori paraméterek és munkakönyvtár megadása az indítandó folyamathoz Domain, UserName, Password Folyamat indítása adott felhasználó nevében RedirectStandardInput, Alapértelmezett be- és kimeneti csatorna átirányítása RedirectStandardOutput ErrorDialog Hibaüzenet jelenjen-e meg, ha a folyamat indítása sikertelen UseShellExecute Operációs rendszerhéj programindítófunkciójának használata folyamat indításához Verb A társított fájl megnyitásakor végrehajtandó művelet WindowStyle Kezdeti ablakméret megadása (normál, minimalizált vagy maximalizált méret) Példa új folyamat indítására 0 0 using System; using System.Diagnostics; class Program static void Main() Process newprocess = new Process(); newprocess.startinfo = new ProcessStartInfo("hello.exe", "Pistike"); newprocess.startinfo.errordialog = true; newprocess.startinfo.useshellexecute = false; newprocess.startinfo.redirectstandardoutput = true; newprocess.start(); Console.WriteLine("Az elindított folyamat üzenetei:"); Console.Write(newProcess.StandardOutput.ReadToEnd()); newprocess.waitforexit(); Console.ReadLine(); ProcessExamples\Program.cs
Feladat () Készítsünk konzolos alkalmazást, amely (a számítógépre telepített.net keretrendszer segítségével) képes a parancssorban megadott C# nyelvűforrásfájl lefordítására és az esetleges hibák megjelenítésére! Amennyiben a forráskód hibátlan volt, ezt a program külön üzenetben jelezze! Ötletek: A.NET keretrendszer része a parancssoros C# fordító(csc.exe) A program számára parancssorban megadott adatok kezeléséhez a Main() metódus args paraméterét használhatjuk fel, amely karaktersorozatok tömbjeként tartalmazza az átadott adatokat Ha a forráskód fordítása sikeres, maga a C# fordítóegy néhány soros fejlécen kívül semmilyen üzenetet nem ír ki. A fejléc megjelenítése a /nologo parancssori paraméterrel kapcsolható ki. 0 Megoldás () 0 0 using System; using System.Diagnostics; class Program static void Main(string[] args) if (args.length > 0) ProcessStartInfo startinfo = new ProcessStartInfo(); startinfo.filename = String.Format(@"0\..\Microsoft.NET\Framework\v\csc.exe", Environment.GetFolderPath(Environment.SpecialFolder.System), Environment.Version.ToString()); startinfo.arguments = String.Format(@"/nologo /t:exe 0", args[0]); startinfo.redirectstandardoutput = true; startinfo.useshellexecute = false; Process compilerprocess = Process.Start(startinfo); string output = compilerprocess.standardoutput.readtoend(); compilerprocess.waitforexit(); if (output == String.Empty) Console.WriteLine("A forráskód hibátlan, a fordítás sikerült."); else Console.WriteLine("Hibaüzenetek:" + Environment.NewLine + output); Compiler\Program.cs Feladat () Készítsük el az előzőfeladat bővített megfelelőjét grafikus Windows alkalmazásként is (az elkészült program adjon lehetőséget a forráskód szerkesztésére, betöltésére, mentésére, fordítására és futtatására)! Ötletek: A program a forráskódot fordítás előtt mentse el egy ideiglenes fájlba A futtatáshoz használjuk a Process osztály statikus Start() metódusát
Megoldás () VisualCompiler Szálak A ak elsődleges célja a folyamatokon belüli párhuzamosítás A folyamatok adminisztrációja és váltása igen erőforrásigényes művelet, viszont az általuk nyújtott elszigetelés szintje egy programon belül csaknem mindig szükségtelen. Ezt az ellentmondást oldják fel a ak, amelyek elszigetelést nem nyújtanak, gyors párhuzamos végrehajtást azonban igen. P folyamat T T T P folyamat T T T T P folyamat T A.NET keretrendszer támogatja a ak kezelését is A keretrendszer kihasználja az operációs rendszer támogatását, de a.net ak és az operációs rendszer ai között nem feltétlenül létezik : megfeleltetés (egy valódi on a keretrendszer több a is futhat). A többúság megvalósítási lehetőségei System.Threading.Thread osztály Lehetővéteszi ak egyenkénti létrehozását, azonosítását, állapotvezérlését és megszüntetését. Kezelése egyszerű, viszont sok programozói munkát és pontosságot igényel. System.Threading.ThreadPool osztály Gyakran ismétlődő, rövid ideig tartó, erősen párhuzamos műveletekhez rendelkezésre álló készlet, melynek használatával megtakaríthatóa ak egyenkénti létrehozásának és megszüntetésének időigényes munkája. Kezelése egyszerű és hatékony, de a ak egyéni identitását nem biztosítja. System.ComponentModel.BackgroundWorker osztály A felhasználói felület kezelésének és a háttérben elvégzendő, esetenként igen sokáig tartóműveletek végrehajtásának szétválasztására szolgál. Kezelése kényelmes (az állapotváltozásokról események útján értesíti a felhasználóját), ám korlátozott funkcionalitása miatt kevés célra alkalmas. Aszinkron metódushívás Képviselők és az aszinkron mintát támogató metódusok aszinkron hívása
Szálak kezelése (kivonatos referencia) System.Threading.Thread osztály Metódusok Start() Suspend(), Resume() Abort() GetHashCode() Sleep() Join() Tulajdonságok CurrentCulture, CurrentUICulture IsBackground IsThreadPoolThread ManagedThreadID Name Priority ThreadState Szál indítása Szál felfüggesztése, illetve folytatása Szál leállítása Szál azonosítójának lekérése Várakozás a megadott időintervallum elteltéig Várakozás az adott befejeződésére A hoz tartozó aktuális kultúra, illetve a hoz tartozó felhasználói felület kiválasztott nyelve Az adott háttér vagy előtér* Az adott a ThreadPool egyik a-e A egyedi azonosítója A megnevezése A prioritása (fontossági szintje) A aktuális állapota(i) * A programok futása véget ér, ha az utolsóelőtér is lefutott (az esetleg még futóháttérak ekkor automatikusan megszűnnek). Szálak kezelése (kivonatos referencia) System.Threading.ThreadPool osztály Metódusok QueueUserWorkItem() Metódus végrehajtása egy ThreadPool on A rendelkezésre állóthreadpool ak számának GetAvailableThreads() lekérdezése GetMaxThreads(), Maximálisan rendelkezésre álló, illetve minimálisan GetMinThreads() életben tartott ThreadPool ak számának lekérdezése SetMaxThreads(), Maximálisan rendelkezésre álló, illetve minimálisan SetMinThreads() életben tartott ThreadPool ak számának beállítása RegisterWaitForSingleObject() Várakozás erőforrásra vagy időzítőre Szálak kezelése (kivonatos referencia) System.ComponentModel.BackgroundWorker osztály Metódusok RunWorkerAsync() Háttér indítása CancelAsync() Háttér leállítása ReportProgress Háttér folyamatjelzése Tulajdonságok IsBusy A háttér aktív-e (éppen fut-e) CancellationPending Leállítás folyamatban (leállási kérelem érkezett) WorkerSupportsCancellation A háttér kérés esetén képes idő előtti leállásra WorkerReportsProgress A háttér képes folyamatjelzésre Események DoWork Kezelője a háttérben futtatandó metódus* ProgressChanged A háttér folyamatjelzését fogadó esemény RunWorkerCompleted A háttér futása befejeződött * Ez a metódus (a Windows UI megvalósítási modellje következtében) közvetlenül nem érintkezhet a felhasználói felület elemeivel. Ezek szükséges frissítését és állapotmódosításait a ProgressChanged és a RunWorkerCompleted eseménykezelőkben lehet elvégezni.
Példa új indítására 0 0 using System; using System.Threading; class Program static void Main(string[] args) Console.WriteLine("Szál közvetlen létrehozása"); Console.WriteLine("Fő (sorszáma: 0)", Thread.CurrentThread.GetHashCode()); Thread newthread = new Thread(ThreadMethod); //.NET. esetén: Thread newthread = new Thread(new ThreadStart(ThreadMethod)); newthread.name = "Új "; newthread.start(); newthread.join(); static void ThreadMethod() Console.WriteLine("0 (sorszáma: )", Thread.CurrentThread.Name, Thread.CurrentThread.GetHashCode()); ThreadExamples\Program.cs Feladat () Készítsünk konzolos alkalmazást, amely a ThreadPool osztály segítségével külön on jeleníti meg az egyes ak által folyamatosan növelt saját belsőszámlálóértékét! A program valamilyen megoldással biztosítsa a ak által kiírt adatok vizuális elkülönítését! Ötletek: A QueueUserWorkItem() metódus paramétere egy WaitCallback típusú képviselő, amely visszatérési érték nélküli, egyetlen ( object típusú) paraméterrel rendelkező metódusokat képes tárolni A ThreadPool ai is azonosíthatók a ManagedThreadID tulajdonsággal (azonban előfordulhat például, hogy egy által megkezdett feladatot egy másik folytat és egy harmadik fejez be) A ak közötti váltások megfigyeléséhez érdemes sok munkát adni az egyes aknak és néha várakoztatni őket (ennek legegyszerűbb módja a Thread osztály statikus Sleep() metódusa) 0 Megoldás () ThreadExamples\Program.cs
Feladat () Készítsünk Windows alkalmazást, amely időigényes műveletet futtat a háttérben, a felhasználói felülettől független on! A program legyen képes a művelet indítására és menet közbeni biztonságos megszakítására, a háttérben futóművelet állapotát pedig folyamatjelzővel jelezze! Ötletek: Célszerű a BackgroundWorker osztály segítségével megoldani a feladatot A háttérben futó a ReportProgress() metódussal jelezheti az előrehaladást (ezt az adatot a ProgressChanged esemény második paraméterében kapja meg a megfelelő eseménykezelő metódus) A művelet megszakítását csak akkor kíséreljük meg, ha valóban fut (ez az IsBusy tulajdonság vizsgálatával állapítható meg) A háttérben futóművelet végén a RunWorkerCompleted esemény kezelője a második paraméterben kap információt a műveletről (véget ért vagy megszakítás miatt fejeződött be, mi a végeredmény, történt-e hiba stb.) Megoldás () BackgroundWorker Aszinkron metódushívás Új képviselődefiniálásakor a C# fordítóolyan új osztályt hoz létre, amellyel szinkron és aszinkron módon is meghívható(k) a képviselt metódus(ok) A képviselőközvetlen (szinkron) hívásakor a képviselőinvoke() metódusa hajtódik végre, azaz a fordítóa képviselőpéldány()szintaxissal megadott metódushívásokat automatikusan képviselőpéldány.invoke() hívásra alakítja át ezért lehet tehát egyszerű szintaxissal meghívni egy képviselőt. Aszinkron hívás esetén a képviselt metódus(ok) két részletben hívható(k): delegate «visszatérési típus» Képviselő(«paraméterek»); Képviselő k = new Képviselő(«hívandó metódus»); IAsyncResult «objektum» = k.begininvoke(«argumentumok»); «visszatérési //...tetszőleges típus» kód, eredmény amely a = képviselt k.endinvoke(k.begininvoke(«argumentumok»)); k(«argumentumok»); k.invoke(«argumentumok»); metódussal párhuzamosan fut majd «visszatérési típus» eredmény = k.endinvoke(«objektum»); A fenti ún. aszinkron tervezési mintát (Begin.../End...) a képviselőkön kívül számos.net osztály is megvalósítja Fájl- és hálózatkezelés, távoli objektumok, webszolgáltatások, üzenetsorok
Példa aszinkron metódushívásra 0 0 using System; using System.Threading; class Program delegate int TestDelegate(string parameter); static void Main(string[] args) Console.WriteLine("A fő elindult"); TestDelegate d = Method; //.NET. esetén: TestDelegate d = new TestDelegate(Method); IAsyncResult asyncresult = d.begininvoke("szervusz, világ!", null, null); Console.WriteLine("A fő kezdeményezte a metódushívást és párhuzamosan tovább fut"); int result = d.endinvoke(asyncresult); Console.WriteLine("A metódus lefutott, visszatérési értéke: 0", result); static int Method(string argument) Console.WriteLine("\tA metódus párhuzamosan fut, kapott paramétere: 0", argument); return ; Szinkronizáció A párhuzamos programozás alapproblémája: bármely két utasítás végrehajtása között előfordulhat, hogy más (ak) kapnak lehetőséget az előző által is kezelt közös adatok kezelésére Egyprocesszoros rendszereknél az operációs rendszer ütemezője (a ak közötti váltás) ad erre lehetőséget, többprocesszoros rendszereknél pedig a valódi (fizikai) párhuzamosság miatt még gyakrabban merül fel a probléma. Ennek elkerülését szolgálják elsősorban a különbözőszinkronizációs megoldások (másik, ezzel összefüggő céljuk az időzítések összehangolása). A szinkronizációolyan, párhuzamos ak (vagy folyamatok) együttműködését megvalósítómechanizmus, amely minden körülmények között biztosítja a ak (vagy folyamatok) által végzett műveletek szemantikai helyességét A párhuzamosan futóak kommunikációjához szinte biztosan szükség van közös erőforrások (memória, portok, I/O eszközök, fájlok) használatára. Ha ezek állapotát egy módosítja, de közben más ak is hozzájuk férnek, akkor az utóbbi ak könnyen hibás vagy félkész adatokhoz juthatnak. Példa egyszerű C# kód összetettségére A sötétebb színűvonalak olyan lehetséges megszakítási pontokat jelölnek, amelyek szinkronizációs problémákat okozhatnak
Szinkronizáció kölcsönös kizárással Kritikus szakasz ( critical section ) A programokon belül megjelölt kritikus kódrészletek soros végrehajtását biztosítja több párhuzamos esetén is..net osztályok: System.Threading.Monitor(és a C# lock utasítása), System.Threading.Mutex, System.Threading.ReaderWriterLock Szemafor ( semaphore ) A kritikus szakasz általánosítása (többpéldányos erőforrások esetén egyszerre több belépését is lehetővé teszi)..net osztály: System.Threading.Semaphore (.NET.0) Atomi végrehajtás ( interlocked execution ) Egyes egyszerű műveletek oszthatatlan végrehajtását biztosítja (igen gyors)..net osztály: System.Threading.Interlocked Csővezeték ( pipe ) Olvashatóés írhatófifo puffer, amely szükség szerint várakoztatja az igénylőket (az ún. termelő-fogyasztó probléma megoldására készült). Szinkronizáció bevárással (randevú) Esemény ( event ) Két kódrészlet soros végrehajtását biztosítja úgy, hogy a B kódrészletet végrehajtó megvárja, amíg az A kódrészletet végrehajtó végez feladatával, illetve lehetőséget ad alkalmankénti vagy rendszeres jelzésre is..net osztályok: System.Threading.Thread, System.Threading.AutoResetEvent, System.Threading.ManualResetEvent Időzítő( timer ) Relatív vagy abszolút időhöz való igazodást tesz lehetővé..net osztályok: System.Windows.Forms.Timer, System.Timers.Timer, System.Threading.Timer Időzítők jellemzői Windows.Forms.Timer Pontosság ~0 ms Futtatás saját on Beállítható első aktiválás Vizuális komponens + Platformfüggetlen Timers.Timer ~00 ns (!) + Threading.Timer ~ ms + + + Példa szinkronizációra (a lock utasítás) 0 0 using System; using System.Threading; class Program private static int counter = 0; private static object lockobject = new Object(); static void Main(string[] args) Thread t = new Thread(ThreadMethod); t.start(); Thread t = new Thread(ThreadMethod); t.start(); private static void ThreadMethod() lock (lockobject) counter++; Thread.Sleep(00); Console.WriteLine("A számláló állása: " + counter); A lock utasítás nélkül a metódus sorosan (egy on futtatva) helyesen működik, párhuzamosan (több on) azonban nem Figyelem: SOHAne írjunk le az alábbiakra hasonlítókódot: lock (this) vagy lock (typeof(program)) 0 0
A szinkronizáció két alapvető nehézsége Versenyhelyzet ( race condition ) Párhuzamos futtatás esetén a közösen használt erőforrásokhoz történő hozzáférés szabályozatlansága veszélyezteti a program helyes működését. Az előző példa a lock utasítás nélkül jól illusztrálja a versenyhelyzet fogalmát. Holtpont ( deadlock ) Akkor léphet fel holtpont, ha több több erőforráshoz kíván hozzáférni, miközben egyes erőforrásokat lefoglalva tartanak (tehát már beléptek egy erőforráshoz tartozókritikus szakaszba, ott viszont várakozniuk kell, hogy hozzájuthassanak egy másik szükséges erőforráshoz). Példa: lock (a) // feldolgozás lock (b) // feldolgozás. lock (b) // feldolgozás lock (a) // feldolgozás. Feladat () Készítsünk többúkonzolos alkalmazást, amely egy időigényes számítási műveletet lal párhuzamosan végeztet el! A műveletet most egy közösen használt számlálófolyamatos növelése jelentse, és egy nak kb. - másodpercig tartson a művelet elvégzése! Amennyiben szükséges, gondoskodjon a ak szinkronizációjáról is! A program valamilyen megoldással biztosítsa a ak által kiírt adatok vizuális elkülönítését! Ötletek: A Stopwatch osztály metódusai segítségével egyszerűen mérhetőaz eltelt (relatív) idő Először egy egyszerűmegvalósítással döntsük el, szükség van-e szinkronizációra, majd ha úgy ítéljük meg, hogy igen, akkor használjuk a lock utasítást vagy a Monitor osztály statikus Enter(), illetve és Exit() metódusát Szinkronizáció esetén a jobb teljesítmény érdekében igyekezzünk a lehető legrövidebbre venni a kritikus szakaszt Irodalomjegyzék (alapismeretek) C. Nagel, B. Evjen, J. Glynn, M. Skinner, K. Watson, A. Jones: Professional C# 00 Kiadó: Wiley Publishing, Inc., 00 ISBN: -0--- Web: http://www.wiley.com/, http://www.wrox.com/ Nyelv: angol Terjedelem: 0 oldal Folyamatok kezelése:.,. o. Szálkezelés:. o. C. Nagel, B. Evjen, J. Glynn, K. Watson, M. Skinner: Professional C# 00 Kiadó: Wiley Publishing, Inc., 00 ISBN: -0-0-- Web: http://www.wiley.com/, http://www.wrox.com/ Nyelv: angol Terjedelem: oldal Folyamatok kezelése:.,. o. Szálkezelés:. o. Microsoft Corp., Visual Studio Developer Center Szálkezelés a.net keretrendszerben: http://msdn.microsoft.com/en-us/library/esxdd(vs.0).aspx
Irodalomjegyzék (magasszintű ismeretek) Albert I., Balássy Gy., Charaf H., Erdélyi T., Horváth Á., Levendovszky T., Péteri Sz., Rajacsics T.: A.NET Framework és programozása Kiadó: Szak Kiadó, 00 ISBN: --- Web: http://www.szak.hu/ Nyelv: magyar Terjedelem: oldal Párhuzamos programozás: 0. o. Folyamatok kezelése: 0. o. Szálkezelés és szinkronizáció:. o. J. Richter: CLR via C#, Second Edition Kiadó: Microsoft Press, 00 ISBN: -0--- Web: http://www.wintellect.com/ Nyelv: angol Terjedelem: oldal Szálkezelés és szinkronizáció:. o.