„Join minta” változatai közötti eltérés
[ellenőrzött változat] | [ellenőrzött változat] |
→Alapfogalmak: Alkalmazások |
|||
242. sor: | 242. sor: | ||
A mobil ágensek autonóm programágensek társas készségekkel, kommunikációs lehetőségekkel és mozgási lehetőségekkel. A program és adatai mozoghatnak különféle gépek között futás közben. |
A mobil ágensek autonóm programágensek társas készségekkel, kommunikációs lehetőségekkel és mozgási lehetőségekkel. A program és adatai mozoghatnak különféle gépek között futás közben. |
||
A mobil ágensek használhatók arra, hogy összekapcsolják a konkurrens és az elosztott programozást join kalkulussal. Ezért megalkották az elosztott join kalkulus fogalmát, ami helyekkel és primitívekkel bővíti a join kalkulust a mobilitás leírására. Így az ágenseknek van fogalmuk a lokációról, ami az ágens fizikai helyét jelenti. Az ágens atomi jelleggel mozoghat a különböző helyek között. |
A mobil ágensek használhatók arra, hogy összekapcsolják a konkurrens és az elosztott programozást join kalkulussal. Ezért megalkották az elosztott join kalkulus fogalmát, ami helyekkel és primitívekkel bővíti a join kalkulust a mobilitás leírására. Így az ágenseknek van fogalmuk a lokációról, ami az ágens fizikai helyét jelenti. Az ágens atomi jelleggel mozoghat a különböző helyek között.<ref name="A Calculus of Mobile Agents">{{cite journal |
||
| last1 = Fournet | first1 = Cédric |
|||
| last2 = Gonthier | first2 = Georges |
|||
| last3 = Levy | first3 = Jean-Jacques |
|||
| last4 = Maranget | first4 = Luc |
|||
| last5 = Remy | first5 = Didier |
|||
| title = A Calculus of Mobile Agents |
|||
| location = Le Chesnay |
|||
| year = 1996 |
|||
| publisher = Concurrency Theory |
|||
| url = http://www.springerlink.com/index/PP23215G0035M6NQ.pdf |
|||
}}</ref> |
|||
Egy ágens folyamata funkcionalitásainak halmazaként definiálható, amibe beletartozik az aszinkron üzenetátadás, és a vándorlás. A mozgás könnyebb reprezentációja érdekében a helyeket fába szervezik. Ezzel a hibázás is egyszerűbben modellezhető. Ha egy helyen összeomlik a program, akkor minden alatta levő helyen is összeomlik. Egy meghatározott helyű hiba bármely futási helyről megtalálható, ez segít kijavítani a hibát. |
Egy ágens folyamata funkcionalitásainak halmazaként definiálható, amibe beletartozik az aszinkron üzenetátadás, és a vándorlás. A mozgás könnyebb reprezentációja érdekében a helyeket fába szervezik. Ezzel a hibázás is egyszerűbben modellezhető. Ha egy helyen összeomlik a program, akkor minden alatta levő helyen is összeomlik. Egy meghatározott helyű hiba bármely futási helyről megtalálható, ez segít kijavítani a hibát.<ref name="A Calculus of Mobile Agents" /> |
||
⚫ | Így a join kalkulus egy elosztott nyelv magja. Operációs szemantikája egyszerűen implementálható egy elosztott rendszerben, ami a hiba lehetőségét is tartalmazza. Így a join kalkulus elsőrangú objektumokként kezeli a csatornákat és a helyeket. Egy hely ismeri más helyek nevét, ezért onnan oda lehet lépni. Ez biztos alapot teremt a statikus elemzésnek és a biztonságos mozgásnak. Teljes az elosztott helyek kifejezésében. Ha nincs hiba, akkor a végrehajtás független a helyektől. Ez az átláthatóság fontos a mobil ágensek tervezésében, és nagyon hasznos tulajdonságaik ellenőrzéséhez. |
||
⚫ | Így a join kalkulus egy elosztott nyelv magja. Operációs szemantikája egyszerűen implementálható egy elosztott rendszerben, ami a hiba lehetőségét is tartalmazza. Így a join kalkulus elsőrangú objektumokként kezeli a csatornákat és a helyeket. Egy hely ismeri más helyek nevét, ezért onnan oda lehet lépni. Ez biztos alapot teremt a statikus elemzésnek és a biztonságos mozgásnak. Teljes az elosztott helyek kifejezésében. Ha nincs hiba, akkor a végrehajtás független a helyektől. Ez az átláthatóság fontos a mobil ágensek tervezésében, és nagyon hasznos tulajdonságaik ellenőrzéséhez.<ref name="A Calculus of Mobile Agents" /> |
||
2007-ben kiadták az alap join kalkulus egy proaktív ágenseket kezelő kiegészítését. Az ágensek megfigyelhetik közös környezetüket. Ehhez a közös környezethez változók adhatók az ágensekkel, például egy névszolgáltató, ami segít megtalálni más ágenseket.<ref>{{cite journal |
|||
| last1 = Maludzinski | first1 = Slawomir |
|||
| title = Multi-Agent Systems and Applications V |
|||
| volume = 4696 |
|||
| last2 = Dobrowolski | first2 = Grzegorz |
|||
| year = 2007 |
|||
| pages=298–300 |
|||
| url = http://link.springer.com/chapter/10.1007/978-3-540-75254-7_30 |
|||
| doi = 10.1007/978-3-540-75254-7_30 |
|||
| chapter = Agent Environment and Knowledge in Distributed Join Calculus |
|||
| series = Lecture Notes in Computer Science |
|||
| isbn = 978-3-540-75253-0 |
|||
| journal=Lecture Notes in Computer Science |
|||
}}</ref> |
|||
A lap 2017. július 4., 13:18-kori változata
A join minta egy konkurrens (párhuzamos, elosztott) programtervezési minta, aminek lényege, hogy a szálak üzenetátadással kommunikálnak. A zárolással szemben magas szintű programozási modell, ami kommunikációs szerkezetmodellt használ, hogy elvonatkoztasson a környezet bonyolultságától, és lehetővé tegye a skálázást. Az üzenetek elfogyasztását atominak tekinti, még akkor is, ha több csatornán érkeztek az üzenetek.
Ez a minta a join-kalkuluson alapul, és mintaillesztést használ. Konkrétan ezt azzal valósítja meg, hogy lehetővé teszi függvények join definícióját, és/vagy csatornákat, amelyek konkurrens hívásra illeszkednek, továbbá üzenetminták is definiálhatók. Konkurrens programtervezési minták mintája (metaminta), mivel egyszerűbbé és hatékonyabbá teszi ezeknek az entitásoknak a kommunikációt és a többszálú programozási paradigma használatát.
Leírása
A join-minta egy magasabb csővezeték, szinkronizációval és mintaillesztéssel. Angolul chordnak is nevezik. Valójában a fogalom összegezhető illesztéssel és csatlakozással néhány üzenetre, amelyek különböző üzenetsorokból származnak, majd egyetlen kezelővel egyszerre kezeli őket.[1] Az első elvárt kommunikációs lépés jelezhető a when kulcsszóval, a felcsatlakozás és párosítás and kulcsszóval, és a különféle feladatok futtatása a do kulcsszóval. A join minta tipikus formája:
j.When(a1).And(a2). ... .And(an).Do(d)
A When(a1) első argumentuma lehet szinkron vagy aszinkron csatorna, de lehet csatornák tömbje is. Minden további argumentumnak aszinkron csatornának kell lennie.[2]
Pontosabban, ha egy üzenet illeszkedik minták egy összekapcsolt sorozatára, akkor elindul a kezelője egy új szálban, ha aszinkron kontextusban van, különben az üzenetnek várnia kell addig, amíg nem illeszkedik egy minta az ő valamelyik mintájára. Ha több illeszkedés van, akkor nem specifikált, hogy melyik minta választódik ki.[3] Egy eseménykezelővel szemben, ami egy időben egyszerre több alternatív esemény egyikét szolgálja ki, a join minta csatornák konjunkciójára vár, és verseng a végrehajtásért minden más megengedett mintával.[4]
A join mintát pi-kalkulusbeli csatornák halmaza definiálja, ami két műveletet definiál, a küldést és a fogadást; emiatt két join kalkulusbeli névre van szükség, egy x csatornanévre és egy x függvénynévre, az érték megszerzéséhez (egy kérés). A join definíció jelentése x() egy hívása, ami visszadja azt az értéket, ami egy x<> csatornán érkezett. Továbbá ha több függvény fut párhuzamosan, kiváltódik a return folyamat, és együtt szinkronizálódik a többi folyamattal.[5]
J ::= //join patterns
| x<y> //message send pattern
| x(y) //function call pattern
| J | JBIS //synchronization
A kliens perspektívájából a csatorna csak deklarál egy metódust, ugyanazzal a névvel és szignatúrával. A kliens üzenetet küld vagy kérést vált ki a metódus hívásával. A folytató metódusnak várnia kell, amíg kérés vagy üzenet érkezett minden csatornán a folytatás When mondatát követően. Ha a folytatás futni kezd, akkor a csatornahívások argumentumai kikerülnek a sorból (elfogyasztódnak), és atomian átadódnak a folytatás paramétereinek. [6]}}
A legtöbb esetben a szinkron hívások sorrendje nem garantált a jobb teljesítmény érdekében. Az üzeneteket egy másik szál is elfogyaszthatja, így a szálnak lehet, hogy tovább kell várnia egy újabb üzenetre.[7]
Története
π-kalkulus - 1992
A π-kalkulus a folyamatkalkulusok családjába tartozik, aminek segítségével matematikai képletekkel írja le és elemzi a konkurrens számítások sorozatát elnevezett csatornák bevezetésével, így a folyamatok kommunikálhatnak csatornákon keresztül, így leírhatók olyan konkurrens számítások is, amelyek hálózatkonfigurációja dinamikusan, futásidőben változik.
Join kalkulus - 1993
A join minták először Fournet és Gonthier alapvető join kalkulusával jelentek meg, mint aszinkron folyamatalgebra, amit elosztott környezetben hatékony implementációhoz terveztek.[8] A join kalkulus kifejezőképessége megegyezik a π-kalkuluséval. Arra fejlesztették ki, hogy formális megalapozást adjon az elosztott programozási nyelvekhez, így elkerüli a más folyamatkalkulusokban használt kommunikációs szerkezeteket, például a randevúkat.
Elosztott join kalkulus - 1996
A join kalkulus névátadó kalkulus, és egyben magnyelv a konkurrens és elosztott programozáshoz.[9] Az elosztott join kalkulus a join kalkuluson alapul, de az elosztott számításokhoz kibővítve.[10] Mobil ágenseket használ, ahol az ágensek nem egyszerűen programok, hanem futó folyamatok, a saját kommunikációs képességeikkel.
JoCaml, Funnel és Join Java - 2000
A JoCaml[11][12] és a Funnel[13][14] funkcionális programozási nyelvek, amelyek támogatják a join minták deklarálását. Közvetlenül valósítják meg a join kalkulust funkcionális programozási nyelvekben.
Egy másik kiterjesztés egy nem szabványos kiterjesztés, a Java, JoinJava, amit Itzstein és Kearney javasolt.[15]
Polyphonic C# - 2002
Cardelli, Benton és Fournet javasolta a C# bővítését join mintával 2002-ben, ez a Polyphonic C#.
Cω - 2003
A Cω a join kalkulus objektumorientált adaptációja. Tartalmazta a Polyphonic C#-ot a Cω (Comega) 2004-es kiadásában.[16]
Scala Joins - 2007
A Scala Joins egy programkönyvtár, ami lehetővé teszi a join minta alkalmazását a Scala nyelvben a kiterjeszthető mintaillesztés kontextusában, hogy a join mintát a létező aktor alapú keretrendszerbe integrálja.
JErlang - 2009
Az Erlang natívan támogatja a konkurrens, valós idejű és elosztott paradigmát. A folyamatok közötti konkurrenciát bonyolult volt megoldani, ezért egy új nyelvet alkottak, a JErlangot, ami a join kalkuluson alapul.
A klasszikus programozási irodalomban
Join mintával egyszerűen kódolhatók egymással kapcsolatban álló konkurrens problémák, mint aktorok és aktív objektumok.[17]
class SymmetricBarrier {
public readonly Synchronous.Channel Arrive;
public SymmetricBarrier(int n) {
// create j and init channels (elided)
var pat = j.When(Arrive);
for (int i = 1; i < n; i++) pat = pat.And(Arrive);
pat.Do(() => { });
}
}
var j = Join.Create();
Synchronous.Channel[] hungry;
Asynchronous.Channel[] chopstick;
j.Init(out hungry, n); j.Init(out chopstick, n);
for (int i = 0; i < n; i++) {
var left = chopstick[i];
var right = chopstick[(i+1) % n];
j.When(hungry[i]).And(left).And(right).Do(() => {
eat(); left(); right(); // replace chopsticks
});
}
class Lock {
public readonly Synchronous.Channel Acquire;
public readonly Asynchronous.Channel Release;
public Lock() {
// create j and init channels (elided)
j.When(Acquire).And(Release).Do(() => { });
Release(); // initially free
}
}
- [[Termelő-fogyasztó minta] [21]
class Buffer<T> {
public readonly Asynchronous.Channel<T> Put;
public readonly Synchronous<T>.Channel Get;
public Buffer() {
Join j = Join.Create(); // allocate a Join object
j.Init(out Put);
// bind its channels
j.Init(out Get);
j.When(Get).And(Put).Do // register chord
(t => { return t; });
}
}
class ReaderWriterLock {
private readonly Asynchronous.Channel idle;
private readonly Asynchronous.Channel<int> shared;
public readonly Synchronous.Channel AcqR, AcqW,
RelR, RelW;
public ReaderWriterLock() {
// create j and init channels (elided)
j.When(AcqR).And(idle).Do(() => shared(1));
j.When(AcqR).And(shared).Do(n => shared(n+1));
j.When(RelR).And(shared).Do(n => {
if (n == 1) idle(); else shared(n-1);
});
j.When(AcqW).And(idle).Do(() => { });
j.When(RelW).Do(() => idle());
idle(); // initially free
}
}
class Semaphore {
public readonly Synchronous.Channel Acquire;
public readonly Asynchronous.Channel Release;
public Semaphore(int n) {
// create j and init channels (elided)
j.When(Acquire).And(Release).Do(() => { });
for (; n > 0; n--) Release(); // initially n free
}
}
Alapfogalmak
- Join kalkulus: A join minta első megvalósításai ezen alapulnak.
- Üzenetátadás: A join minta párhuzamossági okok miatt üzenetátadással működik.
- Csatorna: Csatornák szinkronizálják és adnak át üzeneteket a konkurrensen végrehajtott szálak között. Általában egy csatorna több join mintában is benne van, minden minta egy lehetséges folytatást definiál, ami lefuthat, ha a csatorna meghívódik.[6]
- Szinkron: A join minta használhat szinkron csatornákat, amelyek eredményt adnak vissza. A szinkron minta folytatása a szinkron hívó szálában fut.[6]
- Aszinkron: Az aszinkron csatornának nincs visszatérési értéke, de argumentumai lehetnek. Folytatása egy új szálban fut. A join minta teljesen aszinkron lehet, folytatását szubrutinban nyújtja, és When mondata csak aszinkron csatornákat tartalmaz.[6]
- Szinkron és aszinkron: A szinkron és aszinkron bufferek kombinációja egy olyan modult eredményez, ami kétféle fogyasztót támogat.[6]
- Ütemező: a join mintákat ütemezni kell, kell egy ütemező, ami ezt megoldja.[6]
- Progamtervezési minták: a join minta konkurrens viselkedési programtervezési minta.
- Konkurrens programozás: Konkurrensen hajtódik végre.
- Mintaillesztés: a join minta illeszkedő feladatokkal működik.
- Párhuzamos programozás: párhuzamosan hajtódnak végre a feladatok.
- Elosztott programozás: a join mintával felosztott feladatokat különböző ágensek hajthatják végre különböző környezetekben.
- Tranzakcionális memória: alkalmas a join minta kommunikációjának megvalósítására.
- Átfedés: a join minta számára nem probléma a különböző join minták közötti átfedés, egy csatornára több join minta is hivatkozhat.
Alkalmazások
A mobil ágensek autonóm programágensek társas készségekkel, kommunikációs lehetőségekkel és mozgási lehetőségekkel. A program és adatai mozoghatnak különféle gépek között futás közben.
A mobil ágensek használhatók arra, hogy összekapcsolják a konkurrens és az elosztott programozást join kalkulussal. Ezért megalkották az elosztott join kalkulus fogalmát, ami helyekkel és primitívekkel bővíti a join kalkulust a mobilitás leírására. Így az ágenseknek van fogalmuk a lokációról, ami az ágens fizikai helyét jelenti. Az ágens atomi jelleggel mozoghat a különböző helyek között.[22]
Egy ágens folyamata funkcionalitásainak halmazaként definiálható, amibe beletartozik az aszinkron üzenetátadás, és a vándorlás. A mozgás könnyebb reprezentációja érdekében a helyeket fába szervezik. Ezzel a hibázás is egyszerűbben modellezhető. Ha egy helyen összeomlik a program, akkor minden alatta levő helyen is összeomlik. Egy meghatározott helyű hiba bármely futási helyről megtalálható, ez segít kijavítani a hibát.[22]
Így a join kalkulus egy elosztott nyelv magja. Operációs szemantikája egyszerűen implementálható egy elosztott rendszerben, ami a hiba lehetőségét is tartalmazza. Így a join kalkulus elsőrangú objektumokként kezeli a csatornákat és a helyeket. Egy hely ismeri más helyek nevét, ezért onnan oda lehet lépni. Ez biztos alapot teremt a statikus elemzésnek és a biztonságos mozgásnak. Teljes az elosztott helyek kifejezésében. Ha nincs hiba, akkor a végrehajtás független a helyektől. Ez az átláthatóság fontos a mobil ágensek tervezésében, és nagyon hasznos tulajdonságaik ellenőrzéséhez.[22]
2007-ben kiadták az alap join kalkulus egy proaktív ágenseket kezelő kiegészítését. Az ágensek megfigyelhetik közös környezetüket. Ehhez a közös környezethez változók adhatók az ágensekkel, például egy névszolgáltató, ami segít megtalálni más ágenseket.[23]
- ↑ Taral Dragon: Join Calculus, 2009. október 25. (Hozzáférés: 2012)
- ↑ (2008. október 23.) „Join Patterns for Visual Basic”, Nashville, Tennessee, USA, 10. o.
- ↑ Parallel C#. (Hozzáférés: 2012)
- ↑ „Join Patterns for Visual Basic”, 2. o.
- ↑ (2002) „The Join Calculus: a Language for Distributed Mobile Programming”, Caminha, 8. o.
- ↑ a b c d e f Join Patterns for Visual Basic Claudio V. Russo.
- ↑ (2008. október 23.) „Join Patterns for Visual Basic”, Nashville, Tennessee, USA, 5. o.
- ↑ (2008. október 23.) „Join Patterns for Visual Basic”, Nashville, Tennessee, USA, 18. o.
- ↑ (2007. szeptember 25.) „Compiling Join-Patterns”, Le Chesnay France.
- ↑ (1996) „A Calculus of Mobile Agents”, Le Chesnay, 406–421. o, Kiadó: Concurrency Theory.
- ↑ (2000. szeptember 1.) „JoCaml: a language for concurrent distributed and mobile programming.”. In Advanced Functional Programming, 4th International SchoolOxford, August 2002 2638.
- ↑ (1999) „JoCaml: Mobile agents for Objective-Caml”. In First International Symposium on AgentSystems and Applications. (ASA'99)/Third International Symposium onMobile Agents (MA'99).
- ↑ (2000. szeptember 1.) „An overview of functional nets.”. Summer School, Caminha, Portugal, September 2000 2395.
- ↑ (2000) „Functional nets.”. In Proceedings of the European Symposium on Programming. Lecture Notes in Computer Science 1782.
- ↑ (2001) „Join Java: An alternative concurrency semantics for Java”. Echnical Report ACRC-01-001, University of South Australia.
- ↑ (2002. június 1.) „Modern concurrency abstractions for C#.”. In Proceedings of the 16th European Conference on Object-Oriented Programming (ECOOP 2002), number 2374 in LNCS.
- ↑ Singh, Satnam (2007. január 6.). „Higher Order Combinators for Join Patterns using STM”, 1. o.
- ↑ a b (2011. október 27.) „Scalable Join Patterns”, Portland, Oregon, USA, 4. o.
- ↑ (2011. október 27.) „Scalable Join Patterns”, Portland, Oregon, USA, 1. o.
- ↑ a b (2011. október 27.) „Scalable Join Patterns”, Portland, Oregon, USA, 3. o.
- ↑ (2011. október 27.) „Scalable Join Patterns”, Portland, Oregon, USA, 2. o.
- ↑ a b c (1996) „A Calculus of Mobile Agents”, Le Chesnay, Kiadó: Concurrency Theory.
- ↑ (2007) „Multi-Agent Systems and Applications V”. Lecture Notes in Computer Science 4696, 298–300. o. DOI:10.1007/978-3-540-75254-7_30.