„Eseményalapú aszinkron tervezési minta” változatai közötti eltérés

A Wikipédiából, a szabad enciklopédiából
Laptörténet interaktív böngészése
[ellenőrzött változat][ellenőrzött változat]
← Régebbi szerkesztésÚjabb szerkesztés →
Tartalom törölve Tartalom hozzáadva
VizuálisWikiszöveges
Példa befejezése
refek
1. sor: 1. sor:
Az '''eseményalapú aszinkron tervezési minta''' egy [[konkurrens 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.
Az '''eseményalapú aszinkron tervezési minta''' egy [[konkurrens 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==
==Háttere==
A minta aszinkron hívásokat rendszerez, mivel a meghívott metódusok sokáig futhatnak.<ref name="Async.34.2#71139">{{cite web|url=http://www.zeroc.com/doc/Ice-3.2.1/manual/Async.34.2.html#71139 |title=Asynchronous Method Invocation |accessdate=22 November 2008 |work=Distributed Programming with Ice |publisher=ZeroC, Inc. |deadurl=yes |archiveurl=https://web.archive.org/web/20080105093534/http://www.zeroc.com:80/doc/Ice-3.2.1/manual/Async.34.2.html |archivedate=5 January 2008 |df= }}</ref> Ekvivalens az [[Allan Vermeulen]] által 1996-ban leírt ''én tartozom neked'' mintával.<ref>{{cite journal |last=Vermeulen |first=Allan |date=June 1996 |title=An Asynchronous Design Pattern |journal=[[Dr. Dobb's Journal]] |url=http://www.ddj.com/184409898 |accessdate=22 November 2008 }}</ref><ref>{{cite book |last=Nash |first=Trey |title=Accelerated C# 2008 | year=2007 |publisher=Apress |isbn=978-1-59059-873-3 |chapter=Threading in C# }}</ref>
A minta aszinkron hívásokat rendszerez, mivel a meghívott metódusok sokáig futhatnak. Ekvivalens az [[Allan Vermeulen]] által 1996-ban leírt ''én tartozom neked'' mintával.


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.
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. 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.
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.<ref name="active object">{{cite journal | last=Lavender | first=R. Greg |author2=[[Douglas C. Schmidt]] | title=Active Object | url=http://www.cs.wustl.edu/~schmidt/PDF/Act-Obj.pdf | format=PDF | accessdate=22 November 2008 }}</ref> 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==
==Megvalósításai==
===Java osztály===
===Java osztály===
Javában a FutureTask osztály eseményeket használ a probléma megoldására. Ez a változat több adminisztrációval jár, de hasznos szoftverkomponenseket reprezentáló objektumokhoz.
Javában a FutureTask osztály eseményeket használ a probléma megoldására.<ref>{{cite web|title=Class FutureTask |url=https://docs.oracle.com/javase/6/docs/api/java/util/concurrent/FutureTask.html(v=vs.110).aspx |publisher=Oracle |date=2011 |access-date=2015-06-29 }}{{dead link|date=October 2016 |bot=InternetArchiveBot |fix-attempted=yes }}</ref> Ez a változat több adminisztrációval jár, de hasznos szoftverkomponenseket reprezentáló objektumokhoz.
===.NET keretrendszer===
===.NET keretrendszer===
*Aszinkron programozási modell (APM) a .NET 2.0-ig
*Aszinkron programozási modell (APM) a .NET 2.0-ig<ref>{{cite web|title=Asynchronous Programming Model|url=https://msdn.microsoft.com/en-us/library/ms228963(v=vs.110).aspx|publisher=Microsoft|date=2015|access-date=2015-06-29}}</ref>
*Eseményalapú aszinkron minta (EAP) a .Net 2.0-ban
*Eseményalapú aszinkron minta (EAP) a .Net 2.0-ban<ref>{{cite web| title=Event-based Asynchronous Pattern Overview|url = https://msdn.microsoft.com/en-us/library/wewwczdw(v=vs.110).aspx|publisher=Microsoft|date=2015|access-date=2015-06-29}}</ref>
*Feladatalapú aszinkron tervezési minta (TAP) a .NET 4.0-ban
*Feladatalapú aszinkron tervezési minta (TAP) a .NET 4.0-ban<ref>{{cite web|title=Task-based Asynchronous Pattern|url=https://msdn.microsoft.com/en-us/library/hh873175(v=vs.110).aspx|publisher=Microsoft|date=2015|access-date=2015-06-29}}</ref>
===Példa===
===Példa===
A következő példa a minta laza értelmezésén alapul a .NET keretrendszerben. Egy adott Accomplish metódushoz hozzá kell adni a BeginAccomplish és az EndAccomplish metódusokat.
A következő példa a minta laza értelmezésén alapul a .NET keretrendszerben.<ref name="ms228969">{{cite web |url=http://msdn.microsoft.com/en-us/library/ms228969.aspx |title=Asynchronous Programming Design Patterns |accessdate=22 November 2008 |work=.NET Framework Developer's Guide |publisher=Microsoft Developer Network| archiveurl= https://web.archive.org/web/20081122091746/http://msdn.microsoft.com/en-us/library/ms228969.aspx| archivedate= 22 November 2008 <!--DASHBot-->| deadurl= no}}</ref> Egy adott Accomplish metódushoz hozzá kell adni a BeginAccomplish és az EndAccomplish metódusokat.


<source lang="csharp">
<source lang="csharp">
25. sor: 25. sor:
}</source>
}</source>


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. Az AsyncResult objektumtól megkérdezhető, hogy fut-e még a hívott metódus:
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.<ref name="ms228963">{{cite web |url=http://msdn.microsoft.com/en-us/library/ms228963.aspx |title=Asynchronous Programming Overview |accessdate= 22 November 2008 |work=.NET Framework Developer's Guide |publisher=Microsoft Developer Network| archiveurl= https://web.archive.org/web/20081207092841/http://msdn.microsoft.com/en-us/library/ms228963.aspx| archivedate= 7 December 2008 <!--DASHBot-->| deadurl= no}}</ref> Az AsyncResult objektumtól megkérdezhető, hogy fut-e még a hívott metódus:


<source lang="csharp">
<source lang="csharp">
34. sor: 34. sor:
}</source>
}</source>


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.
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.<ref name="ms228972">{{cite web |url=http://msdn.microsoft.com/en-us/library/ms228972.aspx |title=Using an AsyncCallback Delegate to End an Asynchronous Operation |accessdate= 22 November 2008 |work=.NET Framework Developer's Guide |publisher=Microsoft Developer Network| archiveurl= https://web.archive.org/web/20081223205326/http://msdn.microsoft.com/en-us/library/ms228972.aspx| archivedate= 23 December 2008 <!--DASHBot-->| deadurl= no}}</ref><ref name="Async.34.3#76161">{{cite web|url=http://www.zeroc.com/doc/Ice-3.2.1/manual/Async.34.3.html#76161 |title=Concurrency Issues |accessdate=22 November 2008 |work=Distributed Programming with Ice |publisher=ZeroC, Inc. |deadurl=yes |archiveurl=https://web.archive.org/web/20080328070322/http://www.zeroc.com:80/doc/Ice-3.2.1/manual/Async.34.3.html |archivedate=28 March 2008 |df= }}</ref>


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. 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.
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.<ref name=nageletal>{{cite book|title=Professional C# 2008|author1=Christian Nagel |author2=Bill Evjen |author3=Jay Glynn |author4=Karli Watson |author5=Morgan Skinner |last-author-amp=yes |pages=570&ndash;571|publisher=Wiley|year=2008|isbn13=9780470191378|chapter=Event-based Asynchronous Pattern}}</ref><ref name="hkasytyf">{{cite web |url=http://msdn.microsoft.com/en-us/library/hkasytyf.aspx |title=Multithreaded Programming with the Event-based Asynchronous Pattern |accessdate= 22 November 2008 |work=.NET Framework Developer's Guide |publisher=Microsoft Developer Network| archiveurl= https://web.archive.org/web/20081225175311/http://msdn.microsoft.com/en-us/library/hkasytyf.aspx| archivedate= 25 December 2008 <!--DASHBot-->| deadurl= no}}</ref> 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.<ref name="ms228966">{{cite web |url=http://msdn.microsoft.com/en-us/library/ms228966.aspx |title=Deciding When to Implement the Event-based Asynchronous Pattern |accessdate= 22 November 2008 |work=.NET Framework Developer's Guide |publisher=Microsoft Developer Network| archiveurl= https://web.archive.org/web/20081122092048/http://msdn.microsoft.com/en-us/library/ms228966.aspx| archivedate= 22 November 2008 <!--DASHBot-->| deadurl= no}}</ref>


==Jegyzetek==
{{jegyzetek}}
==Fordítás==
{{fordítás|en|Asynchronous method invocation}}


[[Kategória:Programtervezési minták]]
[[Kategória:Programtervezési minták]]

A lap 2017. június 19., 10:55-kori változata

Az eseményalapú aszinkron tervezési minta egy konkurrens 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

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

Java osztály

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

  • 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

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

  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). (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

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=18847806”