streamalism.org

1. Bemutatkozás

Viszonylag gyakori, hogy a Java programok késleltetést vagy szünetet adnak a működésükhöz. Ez hasznos lehet a feladat ütemezéséhez vagy a végrehajtás szüneteltetéséhez egy másik feladat befejezéséig.

Ez az oktatóanyag a késések Java megvalósításának két módját írja le.

2. A cérna-Alapú megközelítés

Amikor egy Java program fut, akkor ez folyamatot szül ami a gépen fut. Ez a folyamat legalább egy szálat tartalmaz - a fő szálat - amelyben a program fut. Ezenkívül a Java lehetővé teszi a többszálas szálat, amely lehetővé teszi az alkalmazások számára, hogy új szálakat hozzanak létre, amelyek párhuzamosan vagy aszinkron módon futnak a fő szálral.

2.1. Használata Szál.alszik

A Java szüneteltetésének gyors és piszkos módja az, hogy az aktuális szálat meghatározott ideig aludni kell. Ez megtehető a Thread.sleep (ezredmásodpercek):

próbáld ki a {Thread.sleep (secondsToSleep * 1000); } catch (InterruptedException ie) {Szál.currentThread (). megszakítás (); }

Jó gyakorlat a alvás módszer egy try / catch blokkban arra az esetre, ha egy másik szál megszakítja az alvó szálat. Ebben az esetben elkapjuk a InterruptedException és kifejezetten megszakítja az aktuális szálat, így később elkapható és kezelhető. Ez fontosabb egy többszálú programban, de mégis jó gyakorlat az egyszálú programban, ha később más szálakat adunk hozzá.

2.2. Használata TimeUnit.alszik

A jobb olvashatóság érdekében használhatjuk TimeUnit.XXX.sleep (y), hol XXX az az időegység, amikor aludni kell (MÁSODIK, PERCEKstb.), és y annak az egységnek a száma, amelyre aludni lehet. Ez használja Szál.alszik a színfalak mögött. Itt van egy példa a TimeUnit szintaxis:

próbáld meg a {TimeUnit.SECONDS.sleep (secondsToSleep); } catch (InterruptedException ie) {Szál.currentThread (). megszakítás (); }

Azonban, van néhány hátránya ezeknek a szálalapú módszereknek:

• Az alvási idők nem pontosan pontosak, különösen kisebb időnként, például milliszekundum és nanoszekundum esetén
• Ha a hurkok belsejében használják, akkor az alvás kissé eltolódik a hurok iterációi között a más kódfuttatás miatt, így a végrehajtás ideje pontatlanná válhat sok ismétlés után

3. An ExecutorService-Alapú megközelítés

A Java biztosítja a ScheduledExecutorService interfész, amely robusztusabb és pontosabb megoldás. Ez az interfész ütemezheti a kód futtatását meghatározott késleltetés után vagy meghatározott időközönként.

Ha késleltetés után egyszer futtatunk egy darabot, használhatjuk a menetrend módszer:

ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor (); executorService.schedule (Osztálynév :: someTask, delayInSeconds, TimeUnit.SECONDS);

A Osztálynév :: someTask rész, ahol meghatározzuk a késleltetés után futó módszert:

• someTask a végrehajtani kívánt módszer neve
• Osztály név annak az osztálynak a neve, amely tartalmazza a someTask módszer

A feladat rögzített időközönként történő futtatásához használhatjuk a scheduleAtFixedRate módszer:

ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor (); végrehajtóService.scheduleAtFixedRate (Osztálynév :: someTask, 0, delayInSeconds, TimeUnit.SECONDS);

Ez többször hívja a someTask módszer, szüneteltetve delayInSeconds minden hívás között.

Amellett, hogy több időzítési lehetőséget engedélyez, a ScheduledExecutorService A módszer pontosabb időintervallumokat eredményez, mivel megakadályozza a sodródás problémáit.

4. Következtetés

Ebben a cikkben két módszert vitattunk meg a Java programok késéseinek létrehozására.

A cikk teljes kódja a Github oldalon található. Ez egy Maven-alapú projekt, ezért könnyen importálhatónak és futtathatónak kell lennie.