Eseményalapú aszinkron tervezési minta

A Wikipédiából, a szabad enciklopédiából

Az eseményalapú aszinkron tervezési minta egy konkurens programtervezési minta. Lényege, hogy a hívó nem blokkolódik, amíg a hívott válaszára vár, hanem csinálhat mást. A hívó értesítést kap, ha megjön a válasz.

Háttere[szerkesztés]

A minta aszinkron hívásokat rendszerez, mivel a meghívott metódusok sokáig futhatnak.[1] Ekvivalens az Allan Vermeulen által 1996-ban leírt én tartozom neked mintával.[2][3]

A legtöbb programozási nyelvben az objektumhívás szinkron, tehát a hívó blokkolódik, ami különösen hátrányos, ha a hívás sokáig tart, és addig a hívó foglalkozhatna valami mással. Ebben az esetben lehet indítani egy dolgozó szálat, ahonnan a metódust meghívjuk. A legtöbb környezetben ehhez bőbeszédű kódszakasz és plusz adminisztráció szükséges. Ehhez képest az aszinkron hívás azonnal visszatér, további metódusok pedig megkönnyítik a hívó értesítését, vagy ha már nincs más tennivaló, és szükség van az eredményre, akkor a várakozást is.

Az aszinkron hívás egyik használata az aktív objektum tervminta. Alternatívája a szinkron metódushívás ígéret objektummal.[4] Ennek egy példája egy webböngésző, aminek azelőtt meg kell jelenítenie a weboldalakat, hogy a képek betöltődnének.

Megvalósításai[szerkesztés]

Java osztály[szerkesztés]

Javában a FutureTask osztály eseményeket használ a probléma megoldására.[5] Ez a változat több adminisztrációval jár, de hasznos szoftverkomponenseket reprezentáló objektumokhoz.

.NET keretrendszer[szerkesztés]

  • Aszinkron programozási modell (APM) a .NET 2.0-ig[6]
  • Eseményalapú aszinkron minta (EAP) a .Net 2.0-ban[7]
  • Feladatalapú aszinkron tervezési minta (TAP) a .NET 4.0-ban[8]

Példa[szerkesztés]

A következő példa a minta laza értelmezésén alapul a .NET keretrendszerben.[9] Egy adott Accomplish metódushoz hozzá kell adni a BeginAccomplish és az EndAccomplish metódusokat. 

 class Example
 {
   Result       Accomplish(args …)
   IAsyncResult BeginAccomplish(args …)
   Result       EndAccomplish(IAsyncResult a)
   …
 }

A BeginAccomplish hívásakor a kliens azonnal visszakap egy AsyncResult objektumot, ami implementálja az IAsyncResult interfészt. A hívó közben valami mással foglalkozhat. Ha ezzel végzett, akkor meghívja az EndAccomplish metódust, átadva az előbb megkapott objektumot, ami már blokkolja a hívót, amíg nincs kész az eredmény.[10] Az AsyncResult objektumtól megkérdezhető, hogy fut-e még a hívott metódus: 

 interface IAsyncResult
 {
    bool HasCompleted()
   …
 }

Egy callback metódus is átadható a BeginAccomplish metódusnak, ami majd meghívódik, ha a hívott metódus véget ér. Ez tipikusan meghívja az EndAccomplish metódust, hogy megszerezze a végeredményt. Ezzel az a problémája, hogy mivel a dolgozó szálban hívódik meg, versenyhelyzetet okozhat.[11][12]

A .NET keretrendszerben az eseményalapú aszinkron minta egy alternatív API stílusra utal, ami a BeginAccomplish metódus helyett az AccomplishAsync metódust használja. Ezt a .NET 2.0-ban vezették be.[13][14] Ekkor a végeredmény automatikusan a callback metódushoz kerül. Az API speciális mechanizmust használ a callback metódus futtatására, hogy abban a szálban fusson, ami a BeginAccomplish metódust hívta. Ez megszünteti a versenyhelyzet lehetőségét, egyszerűsíti az API használatát, viszont több objektumot hoz létre, ami több időbe kerül.[15]

Jegyzetek[szerkesztés]

  1. ↑ Asynchronous Method Invocation. Distributed Programming with Ice. ZeroC, Inc.. [2008. január 5-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 22.)
  2. ↑ Vermeulen, Allan (1996. június 1.). „An Asynchronous Design Pattern”. Dr. Dobb's Journal. (Hozzáférés: 2008. november 22.)  
  3. ↑ Nash, Trey. Threading in C#, Accelerated C# 2008. Apress (2007). ISBN 978-1-59059-873-3 
  4. ↑ Lavender, R. Greg. „Active Object” (PDF). [2012. szeptember 24-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 22.)  
  5. ↑ Class FutureTask. Oracle, 2011 (Hozzáférés: 2015. június 29.)[halott link]
  6. ↑ Asynchronous Programming Model. Microsoft, 2015 (Hozzáférés: 2015. június 29.)
  7. ↑ Event-based Asynchronous Pattern Overview. Microsoft, 2015 (Hozzáférés: 2015. június 29.)
  8. ↑ Task-based Asynchronous Pattern. Microsoft, 2015 (Hozzáférés: 2015. június 29.)
  9. ↑ Asynchronous Programming Design Patterns. .NET Framework Developer's Guide. Microsoft Developer Network. [2008. november 22-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 22.)
  10. ↑ Asynchronous Programming Overview. .NET Framework Developer's Guide. Microsoft Developer Network. [2008. december 7-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 22.)
  11. ↑ Using an AsyncCallback Delegate to End an Asynchronous Operation. .NET Framework Developer's Guide. Microsoft Developer Network. [2008. december 23-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 22.)
  12. ↑ Concurrency Issues. Distributed Programming with Ice. ZeroC, Inc.. [2008. március 28-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 22.)
  13. ↑ Event-based Asynchronous Pattern, Professional C# 2008. Wiley, 570–571. o. (2008) 
  14. ↑ Multithreaded Programming with the Event-based Asynchronous Pattern. .NET Framework Developer's Guide. Microsoft Developer Network. [2008. december 25-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 22.)
  15. ↑ Deciding When to Implement the Event-based Asynchronous Pattern. .NET Framework Developer's Guide. Microsoft Developer Network. [2008. november 22-i dátummal az eredetiből archiválva]. (Hozzáférés: 2008. november 22.)

Fordítás[szerkesztés]

Ez a szócikk részben vagy egészben az Asynchronous method invocation című angol Wikipédia-szócikk fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét és a szerzői jogokat jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.

A lap eredeti címe: „https://hu.wikipedia.org/w/index.php?title=Eseményalapú_aszinkron_tervezési_minta&oldid=26692952”