Naka-pause sa isang programa

1.Thread.sleep()

Maaari kang magpasok ng mga pause sa pagpapatupad ng isang Java program. Karaniwang hindi ito kinakailangan, dahil gusto ng mga user na tumakbo ang kanilang mga programa nang mabilis hangga't maaari. Hindi maraming tao ang magiging masaya kung sinasadya mong pabagalin ang iyong code.

Ngunit bilang isang programmer, maaaring mayroong maraming mga sitwasyon kung saan ang isang pag-pause sa iyong code ay magiging kapaki-pakinabang. Halimbawa, ipagpalagay na nagsusulat ka ng isang laro at gusto mong gawin ito isang beses bawat dalawang segundo o ilang beses sa isang segundo.

Karaniwan, ang mga pag-pause ay kapaki-pakinabang, kaya tingnan natin kung paano magdagdag ng isang pag-pause sa iyong code. Ito ay talagang napaka-simple:

Thread.sleep(duration);

Nasaan duration ang haba ng pag-pause sa millisecond ( 1/1000ng isang segundo).

Ipo-pause ng statement na ito ang iyong program sa loob ng duration millisecond. Mga halimbawa:

Thread.sleep(2000);

Thread.sleep(500);

Thread.sleep(60 * 60 * 1000);

Narito kung paano ito magagamit sa pagsasanay. Sabihin nating nagsusulat tayo ng isang programa na maglulunsad ng isang spaceship. Ganito ang hitsura ng code:

for (int i = 10; i > 0; i--)
{
   System.out.println(i);
   Thread.sleep(1000);
}

System.out.println("Let's go!");

2. Tamang pagkalkula ng pause

Ang haba ng pag-pause ay madaling kalkulahin. Kung kailangan mo ang program na gumawa ng isang bagay minsan sa isang segundo, ang pag-pause ay 1000 ms. Kung 2 beses bawat segundo, i-pause nang 500ms (1000/2).

Kung kailangan mong gumawa ng isang bagay nang 15 beses bawat segundo, i-pause ng 66 ms (1000/15). Mukhang diretso ang lahat:

The duration of one iteration of the loop = 1000 / number of times per second

Ngunit mayroong isang napakahalagang nuance dito. Bagama't napakabilis ng pagpapatupad ng maraming pahayag, hindi sila agad-agad.

Tignan mo to. Sabihin nating mayroon kang pagkilos na tumatagal ng 100ms bago makumpleto. Gusto mong gawin ang pagkilos na ito 5 beses bawat segundo. Gaano katagal dapat i-pause? Talagang hindi 200ms.

Para maisagawa ang pagkilos nang 5 beses bawat segundo, kailangan namin ang oras na kinakailangan upang maisagawa ang pagkilos kasama ang tagal ng pag-pause na katumbas ng 200 ms. Kung gagawin natin iyon, tiyak na tatakbo ito nang 5 beses bawat segundo. Sa aming kaso, ang pagkilos ay nangangailangan ng 100 ms, na nangangahulugang mayroon pang 100 ms na natitira para sa pag-pause.

pause duration = duration of one iteration of the loop - time required to execute the action

Alam na alam ng mga developer ng laro ang katotohanan na ang oras na kinakailangan upang maisagawa ang isang aksyon ay mas mataas kaysa sa zero. At gayundin ang mga taong naglalaro.

Kung tumatakbo ang isang laro sa 20 FPS, nangangahulugan iyon na maaari lamang itong gumuhit ng 20 frame sa screen sa isang segundo. 1000/20nagbubunga ng 50 ms. Ito ang oras na kinakailangan upang gumuhit ng isang frame habang naglalaro ng laro.

3. Nanosegundo

Ang mga computer ngayon ay mas mabilis kaysa noong nilikha ang Java. Nangangahulugan iyon na ang isang pag-pause ng 1 millisecond ay maaaring hindi sapat na granular.

Ipagpalagay na mayroon tayong napakaikling pagkilos na gusto nating isagawa nang 2000 beses bawat segundo. Paano tayo mag-pause ng kalahating millisecond?

Para dito, may isa pang variant ng Thread.sleep()pamamaraan:

Thread.sleep(milliseconds, nanoseconds);

Pinapatulog ng paraang ito ang program para sa tinukoy na dami ng millisecond at nanosecond.

Ang mga nanosecond ay ika-1 milyon ng isang millisecond. Nangangahulugan iyon na ang isang pag-pause ng isa at kalahating millisecond ay magiging ganito:

Thread.sleep(1, 500_000);

At kung gusto mo ng pause ng 1/10isang millisecond, kailangan mong isulat ito:

Thread.sleep(0, 100_000);

Maaaring hindi mo ginagamit ang paraang ito sa iyong mga programa sa ngayon. Ngunit ito ay mas mahusay na malaman ang tungkol dito at hindi gamitin ito kaysa sa kailanganin ito at hindi alam tungkol dito.

4. TimeUnitklase

Sa pamamagitan ng paraan, ang Java ay may isa pang klase na magpapadali sa iyong buhay kung magpasya kang pabagalin ang iyong aplikasyon. Pinag-uusapan natin ang TimeUnitklase sa java.util.concurrentpackage.

Tandaan na dahil wala ang klase sa java.langpackage, kailangan mong idagdag ang line import java.util.concurrent.TimeUnit;, o isulat java.util.concurrent.TimeUnitang bawat oras sa iyong code.

Ginagawa ng klase na ito ang parehong bagay tulad ng Thread.sleep(), ngunit ito ay mas maginhawa:

TimeUnit.HOURS.sleep(15)

Ang code na ito ay magpapatulog sa iyong programa sa loob ng 15 oras. Available din ang mga minuto, segundo, araw. Pati na rin ang mga microsecond (1/1000,000) at nanosecond (1/1000,000,000).

Ang TimeUnit klase ay may mga sumusunod na katangian:

• nanosecond:NANOSECONDS
• microseconds:MICROSECONDS
• millisecond:MILLISECONDS
• segundoSECONDS
• minuto:MINUTES
• oras:HOURS
• araw:DAYS

Ang paggawa sa mga katangiang ito ay sobrang maginhawa, dahil hindi na kailangang mag-isip tungkol sa pag-convert, halimbawa, mga oras sa millisecond. Ang ganitong code ay mas kaaya-aya na isulat at basahin.

Higit pang mga detalye ay maaaring basahin dito .