A háttérmunkás folyamat rendellenesen leállt. A háttérmunka folyamat rendellenesen leállt. Állásobjektum beszerzése

Kérdés: A háttérmunkafolyamat összeomlott...

Szép napot mindenkinek és jó hetet!)
Vállalati számvitel, 3.0 kiadás (3.0.46.11).
Platform 8.3.9.2033.
A dokumentumok csoportos feladásakor „A háttérfeladat folyamata rendellenesen leállt” hibaüzenet jelenik meg. Nincsenek indokok...
Az SQL szerver újraindítása, 1C szerver (soha nem lehet tudni) nem segít... Esetleg valaki találkozott már hasonló problémával??? Még azt is nehéz megmondani, hogy mikor jelent meg ez a hiba, mert régóta nem használunk csoportos végrehajtást (hónap zárása)...

Válasz:() () Jó napot ismét! Bekapcsoltam a technológiai magazint és ezeket az érdekességeket találtam (talán tudod mi a probléma?):
Kísérlet történt egy olyan objektumon, amely nem foglalat...
A folyamat véget ér. Kimenő hívás elutasítva...
Nem található a szolgáltatást kiszolgáló szerver...

Kérdés: Háttérmunkák

1C platform: Enterprise 8.3 (8.3.9.2170), conf BP 3.0.
A konfiguráció konfigurálja az integrációt külső adatforrásokon keresztül (DBMS-típus - OracleDatabase). Számos tábla került hozzáadásra, amelyekből a törzsadatok és a tranzakciók betöltődnek. Mert Nagyon sok adat volt, ezért úgy döntöttek, hogy kötegelt letöltést hajtanak végre a háttérmunkákon keresztül. Az adag mérete 100 000, a köteg mérete 10 000, a tranzakciók száma a bizonylatban 1000, az egyidejűleg futó háttérfeladatok száma 8.
Elindítom, betöltöm, minden rendben. De ha éjszaka felteszem, akkor olyan érzés, mintha 1c alvó üzemmódba kapcsolna, pl. egy idő után, ahogy a napló mutatja, a háttérfeladatok elindulnak, de nem fejeződnek be. Ennek eredményeként kiderült, hogy a feladatok este 12-kor kezdődtek, és reggel 8-kor (mikor megmozgattam az egeret) befejeződtek, és utána normál módban folytak tovább. Vékony és vastag klienseknél is futtattam. Van egy beállítás a paraméterekben - a passzív munkamenetben az elalvás ideje 1200, de ez nem csak a vékonykliensre vonatkozik, és ez probléma lehet? Nem szeretném letiltani, mert... a felhasználók nem lépnek ki a programból, hagyják elaludni. Találkozott már valaki hasonló problémával? Hogyan döntöttél?

Válasz:

Nincs ilyen lehetőség.

Mi értelme futtatni egy háttérfeladatot, és megvárni, amíg befejeződik?
hogy ne hozzon létre 8-nál több háttérfeladatot?

Húzza a háttérfeladatok "kezelőjét" a szerver oldalára, és hagyja, hogy irányítsa...

40-50 háttérfeladatot futtattam a Pentuim D840-en - normális volt a repülés, aztán a processzor/memória korlátozta.

Kérdés: Hogyan vihetünk át egy fájlt egy háttérmunkába

Platform 8.3.6.2152
Át kell vinnie a fájlt az UV-ről egy háttérmunkába a későbbi feldolgozáshoz.
Ezt tette:
&OnClient
Eljárás Parancs1(Parancs) FájlDD = Új Bináris Adat(Fájlnév); StorageAddressForBackground = Ideiglenes tárolás helye(FájlDD, EgyediIdentifier); Start UploadLoadOnServer(StorageAddressForBackground) EndProcedure &OnServer függvény StartUploadLoadOnServer(StorageAddressForBackground) Method Parameters = Új tömb; MethodParameters.Add(StorageAddressForBackground); Job = BackgroundTasks.Run("MyGeneralModule.MyBackground", MethodParameters); EndFunction
Az általános modulban:

Eljárás MyBackground(Tárhelycím) Exportálás FájlDD = GetFromTemporaryStorage(Tárhelycím); Ha TypeValue(FileDD) = Type("BinaryData") Akkor Naplóbejegyzés Regisztráció Naplóbejegyzés Regisztráció("Debug", "No DD"); EndIf ; Az eljárás vége Ezt próbáltam ki: PlacedFiles = New Array; ElhelyezettFájlok.Add(ÚjDescriptionofTransferFile(Fájlnév)); PlacedFiles = Új tömb; Ha NEM PlaceFiles(PlaceFiles, PlaceFiles, False, UniqueIdentifier) , akkor Return ; EndIf ; StorageAddressForBackground = PlacedFiles.Storage; Ezt próbáltam: StorageAddressForBackground = PlaceInTemporaryStorage(Undefined, UniqueIdentifier); HelyFájl(Háttér tárolási címe, Fájlnév, Hamis);
Normál esetben átmeneti tárhelyen keresztül kerül át a háttérből a kliensbe, de valamiért nem kerül át a kliensről a háttérbe.

Válasz:Általában minden nagyon egyszerűnek bizonyult. Kiderült, hogy a bináris adatokat lehet hülyeségként paraméterként átadni egy háttérmunkának. A szakképzetlen amatőrök számára, hogy hivatkozásokat idézzenek, és elmondják nekik, hogy „így készült”, a működő kód:
&OnClient
Procedure Command1 (Parancs) Indítsa el a UploadLoadOnServer(Új bináris adat(Fájlnév)) EndProcedure
&OnServer függvény StartUploadLoadOnServer(DD) metódus Paraméterek = Új tömb; MethodParameters.Add(DD); Job = BackgroundTasks.Run("MyGeneralModule.MyBackground", MethodParameters); EndFunctions eljárás MyBackground(FileDD) Exportálás, ha TypeValue(FileDD) = Type("BinaryData") then Naplóbejegyzés Regisztráció("Hibakeresés", "Igen DD"); Másképp Naplóbejegyzés Regisztráció("Debug", "No DD"); EndIf ; Vége eljárás

Kérdés: Háttérfeladat futtatása a kívánt felhasználó alatt

Helló!
Van 1C:Enterprise 8.3 (8.3.11.2924), UT 11.3.4.93 kliens - szerver.
Ebben a konfigurációban az "Elszámolások ügyfelekkel bizonylatokon" regiszterben történő mozgások nem a bizonylat feladáskor, hanem a "Késleltetett mozgások végrehajtása ügyfelek\beszállítókkal történő elszámolásokban" rutinfeladattal történnek.
Ugyanakkor néha a rutinfeladat hibát generált, mert zárt időszakban (a szerkesztési tilalom dátuma előtt) próbált mozgásokat tenni. A rutinfeladat beállításaiban regisztráltunk egy speciális felhasználót, akinek a kitiltási dátuma nyitva volt, ezután minden működni kezdett.
Gondoskodni kell azonban arról, hogy ezek a mozgatások a nyilvántartásokban a bizonylat feladásakor történjenek, és ne a háttérmunka ütemezett elindításakor.
Ha magát a kódot futtatja, amely rutinfeladatot hajt végre egy dokumentum feladása során, akkor ugyanaz a hiba lép fel - az időszak zárva van. És ha programozottan futtat egy háttérfeladatot, amely ugyanazt a kódot futtatja a dokumentum feladásakor, akkor pontosan ugyanazt a hibát okozza, mert az időszak lezárul, és a programozottan elindított háttérfeladat az aktuális felhasználó neve alatt indul el, és a kitiltási dátuma lezárul. Ha azonban ütemezetten elindul egy háttérfeladat, amelynél a „megfelelő” felhasználó telepítve van az ütemezőben, akkor minden rohamosan megy. Itt van, hogyan kell ezt programozottan megtenni, hogyan lehet programozottan futtatni egy háttérfeladatot a kívánt felhasználó alatt "az ütemezőn keresztül", ahogy a szokásos ütemezett feladatok teszik.

Válasz:

Nem erre van beállítva?
Ennek konfigurációs hibának kell lennie

Lis2007 mondta:

Helló! Ugyanakkor a rutinfeladat néha hibát generált, mert... zárt időszakban (a szerkesztési tilalom dátuma előtt) próbált mozgásokat tenni. A rutinfeladat beállításaiban egy speciális felhasználót regisztráltunk, akinek a kitiltási dátuma nyitva volt, ezután minden működni kezdett

Kattintson a kibontáshoz...

Kérdés: Háttérfeladat hibakeresése

A háttérfeladat hibával fut. Úgy döntöttem, debuggolok.
Külső feldolgozáson keresztül indítom el egy sorral:
BackgroundTasks.Run("MyModule.MyTask");
A modul töréspontját nem érte el.
A szerveren a hibakeresés engedélyezett, a hibakeresés be van jelölve, az automatikus csatlakozás, a háttérmunkák engedélyezve vannak. Mi lehet még a probléma?

Válasz: Az elterjedt modulokban olyan funkciókat hívtak meg, amelyekhez nem a szerver, hanem a kliens kellett. Zárójelbe kellett tennem őket az #If ClientThen. A háttér is működött.

Kérdés: Hiba a csere végrehajtásakor

Jó napot! Mondd meg, hol ássak:
Cserét végzek a számviteli adatbázisban. Körülbelül három tucat dokumentumot töltenek fel az UT-shka-ból szabványos cserén keresztül. Hosszan gondolkodnak (kb. egy órát), és a következő üzenettel fejezik be:
A háttérben végzett munkafolyamat összeomlott

Valószínűleg minden 1C 8.3 programozónak előbb-utóbb be kellett állítania bizonyos feladatok ütemezett végrehajtását. Az alábbiakban részletes leírást adok ezekről a mechanizmusokról, remélem, ez hasznos információ lesz a kezdő 1C programozók számára. Ez nagyon kényelmes, mert nem igényel emberi beavatkozást, a rutinfeladat egyszer van konfigurálva, és az Ön ütemezése szerint működik.

Az alábbi példa segítségével részletes utasításokat talál.

Mik a rutin- és háttérfeladatok az 1C-ben

• Ütemezett feladatok egy speciális 1C Enterprise 8.3 mechanizmus, amelyet arra terveztek, hogy egy adott műveletet egy adott ütemezés szerint hajtson végre.
• Háttér munka- rutinfeladat által generált objektumok, amelyek közvetlenül hajtják végre a tervezett műveletet a felhasználó vagy az 1C 8.2 programozó részvétele nélkül.

Az ütemezett és háttérmunkák mechanizmusa kliens-szerver módban (SQL) működik, a DBMS funkcionalitásának köszönhetően. Ha van fájl adatbázisa, akkor a feladat is konfigurálható, de egy kicsit más elv szerint.

Háttérfeladatok beállítása 1C kliens-szerver módban

Először is hozzunk létre egy új metaadat objektumot – egy rutinfeladatot. A feladatomat „Valutaárfolyamok betöltése”-nek nevezem. Nézzük meg ennek a konfigurációs objektumnak a tulajdonságpalettáját:

Szerezzen ingyen 267 videóleckét 1C-n:

• A módszer neve— annak az eljárásnak az elérési útja, amely adott ütemezés szerint egy háttérfeladatban fog végrehajtani. Az eljárásnak egy közös modulban kell lennie. Javasoljuk, hogy ne szabványosakat használjon, hanem készítsen sajátot. Ne felejtse el, hogy a háttérben futó feladatok a szerveren futnak!
• Használat— rutinfeladat használatának jele.
• Előre meghatározott— jelzi, hogy a rutinfeladat előre meghatározott-e. Ha azt szeretné, hogy a rutinfeladat azonnal működjön az adatbázisba helyezés után, adja meg ezt a jelzőt. Ellenkező esetben a Job Console feldolgozást kell használnia, vagy a feladatot programozottan kell futtatnia.
• Az újrapróbálkozások száma, ha egy job rendellenesen fejeződik be— hányszor indult újra a háttérfeladat, ha hibásan futott le.
• Újrapróbálkozási időköz, ha a munka rendellenesen fejeződik be— milyen gyakran indul újra a háttérfeladat, ha hibásan fejeződött be.

És a legérdekesebb beállítás az Menetrend:

Itt állíthatja be a „Módszer neve” mezőben megadott eljárás indítási intervallumát. Mondjuk én konfiguráltam

Figyelem! Ne felejtse el letiltani a rutin- és háttérfeladatok végrehajtásának blokkolását DBMS-szinten!

Ezt megteheti a kliens-szerver verzió adminisztrációs segédprogramjában vagy új adatbázis létrehozásakor:

Rutinfeladatok beállítása 1C fájl módban

Fájl módban az ilyen feladatok beállítása valamivel nehezebb. Egy ilyen feladathoz az 1C program külön munkamenetét kell elindítani. Ezt gyakran úgy oldják meg, hogy létrehoznak egy „technikai” felhasználót, akinek a munkamenete mindig fut.

Fájl módban a rutinfeladat inicializálása a „RunTaskProcessing()” metódus indításakor történik.

Egy adott felhasználó számára beállíthatja ezt a metódust úgy, hogy egy másik metódussal fusson -

ConnectWaitHandler( <ИмяПроцедуры>, <Интервал>, <Однократно>).

• Az eljárás neve— a várakozáskezelőként kapcsolt eljárás neve. Egy felügyelt alkalmazásmodul (egy normál alkalmazásmodul) vagy egy globális megosztott modul exportált eljárásának neve. Az eljárást az ügyfélen kell elhelyezni.
• Intervallum— a műveletek végrehajtása közötti időszak másodpercben.
• Egyszer- hogyan kell elvégezni a feladatot, egyszer vagy nem.

ConnectWaitHandler, 3600 );

Egy kétperces videó, amely bemutatja, hogyan kell beállítani egy rutinfeladatot az 1C konfigurátorban:

Valószínűleg az 1C 8.3 vagy 8.2 egyetlen komoly konfigurációja sem nélkülözheti a rutin- és háttérfeladatokat. Nagyon kényelmesek, mivel egyértelműen meghatározott ütemterv szerint kerülnek végrehajtásra, felhasználó vagy programozó beavatkozása nélkül.

Például naponta egyszer kell adatot cserélnie egy másik programmal. A rutin- és háttérfeladatok segítségével az 1C képes lesz önállóan végrehajtani ezeket a műveleteket, például munkaidőn kívül. Ez a módszer semmilyen módon nem befolyásolja a felhasználói élményt, és időt takarít meg.

Először is nézzük meg, mit jelentenek, és mi a különbségük:

• Ütemezett feladat lehetővé teszi bármely konkrét művelet elindítását egy előre konfigurált ütemezés szerint.
• Háttér munka egy objektum, amely tartalmazza a végrehajtandó műveleteket.

Tételezzük fel, hogy cégünk árul valamit, és van saját weboldala, amelyen az árak megtalálhatók. A relevanciájuk megőrzése érdekében naponta egyszer szeretnénk feltölteni őket.

Nyissa meg a konfigurációt, és adjon hozzá egy ütemezett feladatot.

Tulajdonságok beállítása

Nézzük meg a legfontosabb paramétereket, amelyeket ki kell tölteni a tulajdonságaiban.

• mezőben " A módszer neve» egy adott általános modul eljárását választja ki, amely közvetlenül végrehajtásra kerül. Jelzi az árak weboldalunkra történő feltöltésének minden lépését. Felhívjuk figyelmét, hogy a végrehajtás a szerveren történik. Ez logikus, mert a rutinműveleteket a felhasználó részvétele nélkül hajtják végre.
• Az ütemezett feladat szükség szerint letiltható vagy engedélyezhető. Nem kell minden alkalommal módosítani az ütemtervét. Ehhez a tulajdonságok palettán állítsa be vagy törölje a jelzőt " Használat».
• Egy másik fontos dolog annak beállítása, hogy ez a rutinfeladat lesz-e előre meghatározott, vagy nem. Az előre meghatározott ütemezett feladatok automatikusan elindulnak. Ha ez a funkció nincs telepítve, akkor programozottan kell elindítania őket, vagy használnia kell a „Task Console” feldolgozást az ITS-sel.
• Meg is adhatja az ismétlések száma és a köztük lévő intervallum rendellenes felmondás esetén. A rendellenes leállás azokra a helyzetekre vonatkozik, amikor a feladatokat hiba miatt nem fejezték be.

Ütemezés felállítása

Az utolsó lépés a webhelyre való feltöltés ütemezése a tulajdonságok palettán található megfelelő hiperhivatkozás segítségével.

Egy tipikus ütemezési beállítást láthat az 1C 8.3-ban. Nincs itt semmi bonyolult. Ebben a példában minden nap reggel öttől hétig beállítjuk az árak webhelyre történő feltöltését. Abban az esetben, ha az ütemezett feladatot 7:00 előtt nincs ideje elvégezni, az már másnap elkészül.

Ütemezett feladatok blokkolása

Futtassa az „Administering 1C Enterprise Servers” szabványos segédprogramot, és nyissa meg annak az információs bázisnak a tulajdonságait, ahol a rutinfeladatot létrehozta (az 1C kliens-szerver verzióihoz).

A megnyíló ablakban (miután megadta bejelentkezési nevét és jelszavát az információbiztonság eléréséhez), ellenőrizze, hogy a „Rutinfeladatok blokkolása engedélyezve van” jelölőnégyzet nincs-e bejelölve. Ha olyan helyzetbe ütközik, amikor a feladat nem működik, először ellenőrizze ezt a beállítást.

Ugyanígy teljesen letilthatja a rutinfeladatokat az 1C 8.3-ban. Adott háttérfeladatok letiltásához használhatja a „Background Job Console” feldolgozást, amely a legújabb kiadásokban található.

Háttér és ütemezett feladatok fájl módban

Ebben a módban ezeknek a feladatoknak a beállítása és elindítása sokkal nehezebben szervezhető. Leggyakrabban egy további fiók jön létre, amelynek munkamenete mindig nyitva lesz.

Ebben az esetben a rutinfeladatok a „RunTaskProcessing()” metódussal aktiválódnak.

Használhatja a következő konstrukciót is:

Az eljárás neveként meg kell adnia a végrehajtandó kliens eljárás nevét. Az intervallum azt mutatja, hogy hány másodperccel később kerül sor a végrehajtásra. Az „Egyszer” paraméter nem szükséges. Ez tükrözi, hogy ezt az eljárást egyszer vagy többször hajtják végre.

Követési hibák a háttérmunkákban

A naplóban megtekintheti a háttérben végzett feladatok előrehaladását, valamint a lehetséges hibák jelenlétét. A szűrőben válassza ki a „Háttérmunka” alkalmazást, és ha szükséges, válassza ki az érdeklődés fontosságát, például csak a „Hibák”.

A napló megjeleníti az összes olyan bejegyzést, amely megfelel a választásának, egy megjegyzéssel együtt, amely segít megérteni a hiba okát.

Aszinkron programozási koncepció

Az aszinkron programozási koncepció az, hogy egy függvény eredménye nem azonnal elérhető, hanem egy idő után valamilyen aszinkron (a normál végrehajtási sorrendet megsértő) hívás formájában.

Azok. Az aszinkron programozás fő gondolata, hogy egyéni metódushívásokat adjon ki, és párhuzamosan folytassa a többi munkát anélkül, hogy megvárná a hívások befejezését.

Egyes módszerek, amelyek minimalizálják a kivételek valószínűségét, nem igényelnek aszinkron megközelítést, mások viszont a fejlesztés legelején.

Amint az a grafikonokból látható, szinkron programozási modell esetén nincs együtthatója a hasznos interaktív felhasználói műveleteknek, mivel a rendszer blokkolja a felhasználói felületet, míg aszinkron modell esetén a felhasználó továbbra is aktívan dolgozik a rendszerben.

Szinkron futás esetén az alkalmazásnak csak egy szála van. Az aszinkron programozási modellel több szálat futtathat párhuzamosan, és futás közben reagálhat az új felhasználói műveletekre. Az n-szál végrehajtása után az eredmény megjelenik a képernyőn.

Háttérfeladatok az 1C:Enterprise 8-ban

Az 1C:Enterprise 8-ban a háttérfeladatokat úgy tervezték, hogy az alkalmazási feladatokat aszinkron módon hajtsák végre. Létrehozhatnak alárendelt háttérfeladatokat, például a fürt különböző működő szerverein végzett összetett számítások párhuzamosításához kliens-szerver üzemmódban.

Lehetőség van az azonos módszerekkel rendelkező háttérfeladatok végrehajtásának korlátozására egy adott alkalmazási feltétel alapján. A háttérfeladatok programozott létrehozása és kezelése lehetséges bármely felhasználói kapcsolatról a rendszer információs bázisához. A háttérfeladat annak a felhasználónak a nevében fut, aki létrehozta.

A feladatmechanizmus kliens-szerver és fájl üzemmódban is működik, de a feladatok adminisztrációs és végrehajtási lehetőségei mindkét verzióban némileg eltérőek.

Kliens-szerver opció

A kliens-szerver verzióban a feladatütemezést a feladatütemező végzi, amely fizikailag a fürtkezelőben található.

Az ütemező rendszeresen ellenőrzi, hogy érkezett-e kérés a háttérfeladatok futtatására. Ha vannak végrehajtandó jobok, az ütemező meghatározza a fürt legkevésbé terhelt dolgozói folyamatait, és egymás után mindegyikhez hozzárendeli a végrehajtandó feladatot. Így ugyanaz a dolgozói folyamat potenciálisan több feladatot is végrehajthat párhuzamosan. Miután a dolgozói folyamat megkapta a munkát, a dolgozói folyamat kapcsolatot létesít az információs bázissal, és végrehajtja a feladatot ezen a kapcsolaton belül. A munka befejezése után a dolgozói folyamat értesíti az ütemezőt, hogy a feladat sikeresen vagy sikertelenül fejeződött-e be.

Fájl opció

A platform 8.3.3.641-es verziójától kezdve a fejlesztők jelentősen leegyszerűsítették a munkát a háttérfeladatokkal a fájlverzióban.

Korábban a feladatok automatikus végrehajtásához külön, további 1C:Enterprise munkamenetet kellett elindítani, amelyet feladatütemezőként használtak. És ebben a munkamenetben szükség volt a beépített nyelvi módszer időszakos végrehajtására ExecuteTaskProcessing(). Ez a megközelítés meglehetősen körülményes, kényelmetlen volt, és nagymértékben korlátozta a háttér- és rutinfeladatok használatát a munka fájlváltozatában.

Most minden sokkal könnyebbé vált. Ha egy vékony vagy vastag kliens indul, és ha a webszervernek is vannak klienskapcsolatai, akkor ezekben az alkalmazásokban automatikusan elindul egy másik szál az adatbázishoz való csatlakozással. Ezek a szálak háttér- és rutinfeladatok végrehajtásával foglalkoznak.

A felsorolt ​​alkalmazások mindegyike elvégzi a saját háttérfeladatait. Ha egy alkalmazás több háttérfeladatot kezdeményezett, azok egymás után, a beérkezésük sorrendjében kerülnek végrehajtásra.

Az 1C háttérmunkák nyilvánvaló hátránya: mivel a szerver oldalon futnak, nincs lehetőség interaktív munkavégzésre a felhasználóval (például nem lehet üzenetet vagy más információt megjeleníteni; mindezeket az adatokat az információs bázison belül kell tárolni, és tovább kell feldolgozni valamilyen módon).

Meg kell jegyezni, hogy a háttérmunkák tisztán szoftverobjektumok, és nem tárolhatók az adatbázisban. Vagyis csak egy osztály példányát tudjuk létrehozni, a tulajdonságait inicializálni és végrehajtásra elindítani.

Példa az aszinkron kódvégrehajtásra az 1C:Enterprise 8-ban

„Sokkal nehezebb olyan programokat írni, amelyekben egy függvényhívás eredménye ismeretlenül mikor érkezik meg, sokkal nehezebb, mint a hétköznapiak. Beágyazott hívások, hibakezelés, a történések ellenőrzése - minden bonyolultabbá válik” – csak azok mondják ezt, akik nem tudják, hogyan kell megfelelően használni a platform képességeit, de mi nem!

Mutassuk meg az aszinkron kódvégrehajtás egyszerűségét és eleganciáját az 1C:Enterprise 8-ban!

1. lépés. Hozzunk létre egy új információbiztonsági rendszert a konfigurációfejlesztéshez

2. lépés. A konfigurációban hozzáadjuk az „Aszinkron kezelők” általános modult.

Miért adtunk hozzá egy megosztott modult? Itt minden egyszerű: az aszinkron műveletek végrehajtásához az 1C:Enterprise 8-ban háttérfeladatokat használnak, amelyeknek saját kezelőjük van - „BackgroundTask Manager”. Ez az objektum rendelkezik egy „Futtatás” metódussal, melynek segítségével elindul a háttérfeladat.

Forduljunk a szintaktikai asszisztenshez.

Tehát szükségünk lesz egy közös modulra.

3. lépés Az „Asyncronous Handlers” általános modulban hozzáadjuk az OurLongOperation() exportálási eljárást.

Eljárás OurLongOperation(Duration) Export // Hosszú távú művelet szimulációja (Duration sec.). OperationStartDate = AktuálisDátum(); Míg CurrentDate() - A művelet kezdő dátuma< Длительность Цикл КонецЦикла; КонецПроцедуры

4. lépés. Adja hozzá az „Asynchronous Programming Concept” feldolgozást a konfigurációhoz (külső feldolgozást hozhat létre)

Adjon hozzá egy attribútumot az űrlaphoz:

Időtartam (szám)

és két csapat

Végezze el a LongOperation-t;

Végezzen aszinkron hosszú-hosszú műveletet.

5. lépés. A szintaxis asszisztens szerint töltse ki az űrlap modult

&Az ügyféleljáráson hajtsa végre a Long-RunningOperation(Command) ExecuteLong-RunningOperationOnServer(); EndProcedure &OnServer eljárás ExecuteLongOperationOnServer() AsynchronousHandlers.OurLongOperation(Duration); Az eljárás vége &Az ügyfélen Eljárás Hosszan futó művelet végrehajtása aszinkron módon (parancs) Hosszú távú művelet aszinkron végrehajtása a kiszolgálón (); Az eljárás vége &A kiszolgálón Eljárás Hosszan futó művelet végrehajtása aszinkron módon a kiszolgálón() Paraméterek = Új tömb; Parameters.Add(Duration); BackgroundTasks.Execute("AsynchronousHandlers.OurLongOperation", Parameters, New UniqueIdentifier, "Példa aszinkron programozási koncepcióra"); Vége eljárás

6. lépés. Indítsuk el és ellenőrizzük!

Eredmény:

Ha a „Hosszú működés végrehajtása” gombra kattintunk, akkor a felhasználói felület „Időtartam” másodpercekre blokkolva lesz;

Ha a „Hosszú üzemelés aszinkron végrehajtása” gombra kattintunk, a felhasználói felület nem blokkolódik, és a programkód párhuzamosan fut.

A naplóból ellenőrizhetjük, hogy a programkód aszinkron módon fut-e le.

A „háttérben” futó programkódot akkor tudjuk hibakeresni, ha beállítjuk a megfelelő tulajdonságot a hibakeresési paraméterekben.

Példa aszinkron kódvégrehajtásra az 1C:Enterprise 8-ban BSP használatával

Tekintsünk egy példát az aszinkron programozási koncepció megvalósítására az 1C:Enterprise 8-ban a BSP-ben, az „Aktuális ügyek” feldolgozás példájával.

A logika a következő: a program indításakor a kezdőoldal munkaterülete inicializálódik, ahol az „Aktuális” feldolgozási űrlap jeleníthető meg. Ezt az űrlapot a felhasználó aktuális ügyei töltik ki, kitöltése időbe telik. Ha a fejlesztők nem tudták aszinkron kódot futtatni, akkor a felhasználói felület blokkolva lenne a feldolgozási űrlap kitöltése közben!

Elemezzük az űrlap programkódját.

A „When CreatedOnServer” űrlapesemény meghívja a „RunBackgroundTask” eljárást – erre van szükségünk.

Anélkül, hogy az árnyalatok megzavarnák, elemezzük ezt az eljárást

És itt látjuk, hogy a háttérfeladat-kezelőt és annak „Futtatás” módszerét használják. Vegye figyelembe, hogy a fejlesztők egyedi azonosítót tárolnak a háttérmunkához.

Ehhez a fejlesztők a módszert használják ConnectWaitHandler(<ИмяПроцедуры>, <Интервал>, <Однократно>).

A kiakasztott eljárásban Connectable_CheckTaskComplete() a fejlesztők a függvényt hívják Feladat befejezve (Feladatazonosító)

Ez a funkció egy háttérfeladat végrehajtását ellenőrzi azonosító alapján.

Meg kell jegyezni, hogy a BSP általános modulokat fejlesztett ki a hosszú távú szerverműveletek támogatására.

Így az 1C:Enterprise 8 aszinkron programozási koncepciója kissé megnöveli a problémák megoldásának összetettségét a fejlesztő számára, de jelentősen javítja a program funkcionalitását a felhasználó szempontjából.

Lehetővé teszi, hogy a felhasználó által észrevétlenül, azaz a háttérben végezzünk bármilyen számítást a rendszerben. Ezenkívül ez a mechanizmus lehetővé teszi a számítási folyamat párhuzamosítását. Akár párhuzamosíthatjuk is a végrehajtandó eljárást. Ehhez a háttérmunkánknak még több háttérfeladatot kell futtatnia. Ebben az esetben a folyamatok párhuzamosak, és ha többprocesszoros, többmagos rendszerünk van, akkor az algoritmusunk hatékonyan fog működni. Több folyamat elindítása után elmondhatjuk a rendszernek, hogy meg kell várnia ezeknek a folyamatoknak a befejeződését, hogy az eredményt valamilyen módon kombinálja.

Például tipikus konfigurációkban, miközben a felhasználó dolgozik, különféle háttérszolgáltatási feladatok kerülnek végrehajtásra. Ezt olyan naplóbejegyzések igazolhatják, amelyek rögzítik az ilyen műveletek végrehajtásának tényét. Ráadásul ez semmilyen módon nem befolyásolja a felhasználó munkáját, egyszerűen nem veszi észre őket.

Ideális esetben egy háttérfeladatot kliens-szerver verzióban valósítanak meg, ebben az esetben a teljes terhelés a szerverhez kerül. Ami a fájlverziót illeti, lehetséges háttérmunka, de van néhány sajátossága.

Ezt fogja produkálni a rendszer, ha nem veszi figyelembe ezeket a funkciókat, és háttérfeladatot futtat az infobázis fájlverziójában.

Az 1C háttérfeladatnak vannak bizonyos korlátai. Mivel a szerver oldalon fut, nincs lehetőség interaktív munkavégzésre a felhasználóval. Például nem jeleníthet meg üzenetet vagy semmilyen információt. Mindezeket az adatokat az információs bázison belül kell tárolni, és valamilyen módon tovább kell dolgozni.

Ha felveszi a kapcsolatot a szintaktikai asszisztenssel, részletesebb információkat kaphat az 1C háttérmunkáiról. Itt meg kell jegyezni, hogy ez az objektum tisztán szoftver, és semmilyen módon nem kerül tárolásra az adatbázisban. Azaz létrehozzuk az osztály példányát, inicializáljuk a tulajdonságokat és elindítjuk végrehajtásra.

Milyen eszközeink vannak a háttérmunkák kezeléséhez? Ez a lehetőség egy metaadat objektum "Háttérfeladatkezelő". Ennek az objektumnak van egy metódusa "Fuss", ezzel a módszerrel elindul a háttérfeladat.

A következő paraméterekkel rendelkezik:
"Módszernév"- a végrehajtandó eljárás vagy függvény neve, és ennek a szerverkörnyezet egyik eljárásának vagy függvényének kell lennie;

"Lehetőségek"- paraméterek tömbje, melynek elemeinek számának meg kell egyeznie eljárásunk/függvényünk paraméterben megadott számával "Módszernév";

"Kulcs"- egy bizonyos egyediségi kulcs, amely egy sor, amelyen keresztül a rendszer megérti, hogy el kell-e indítani egy háttérfeladatot, vagy fut-e már ilyen feladat;

"Név"- itt megadhatja a módszerünk tetszőleges leírását.

A visszatérési érték egy objektum "Háttérfeladat", amely tartalmazza az aktuális metódus nevét, az aktuális kulcsot, és számos további tulajdonságot és metódust. Az egyik ilyen módszer a módszer "WaitComplete". Célja, hogy meg tudjuk mondani a rendszernek, hogy ne csináljon semmit, amíg a háttérfeladat be nem fejeződik.

Háttérfeladat 1C 8.2, 8.3 - Használati példa

Nézzünk egy példát az 1C háttérmunkákkal való munkavégzésre. Először is létrehozunk egy egyszerű algoritmust, amely rövid időre betölti az 1C rendszert oly módon, hogy jelenleg nem tudunk semmit tenni.

Ezért:

1. Hozzunk létre egy közös modult "Háttérfeladatkezelők", amely a szerver oldalon lesz lefordítva;

2. Leírjuk benne a kiviteli eljárást "ProduceBackgroundCalculation(Parameter)", amely egy karakterlánc típusú paramétert vesz fel;

Eljárás PerformBackgroundCalculation(Parameter) ExportStartTime = CurrentDate() ; Míg CurrentDate() - Kezdési idő< = 6 Цикл КонецЦикла ; КонецПроцедуры Процедура КнНажатие() ОбработчикиФоновыхЗаданий. ПроизветиФоновоеВычисление("Valamilyen paraméter") ; Vége eljárás

Kész. Most, amikor elkezdi a feldolgozást és megnyom egy gombot, a rendszer néhány másodpercre lefagy, ezalatt semmit sem lehet tenni. Pontosan ezt kellett tennünk.

Most gondoskodunk arról, hogy ezek a számítások a háttérben történjenek, vagyis hogy az 1C 8.2, 8.3 háttérfeladat végrehajtásra kerüljön, de ne zavarjon bennünket.

Ezért:

1. A feldolgozás során a gombkattintás eseményébe írja be a következő kódot.

Eljárás KnPress() Paraméterek = Új tömb; Lehetőségek. Add( "Valamilyen paraméter") ; Háttérfeladat. Fuss ( "Háttérfeladatkezelők. Végezze el a háttérszámítást", Paraméterek, Új egyedi azonosító, "Teszt") ; Vége eljárás

Itt első paraméterként a közös moduleljárás nevét adjuk át, másodikként pedig egy paramétertömböt. A harmadik paraméternek egy egyedi kulcsot kell átadni, a negyedik paraméternek pedig az eljárásunk leírását.