[java] delay in miliseconds

[Verwijderd]

Hallo iedereen,

weet iemand of het mogelijk is om een korte pauze in het programma in te bouwen, een pauze van 1 milisec is noodzakelijk

[Verwijderd]

nog een extraatje, het mag dus geen klasse zijn die swing of awt is, deze mogen wie niet gebruiken van onze prof

[marcusk]

1 milliseconde? das niet veel.

code:

private void wait(int p_milliseconds)
{
    long cur, end = (new Date()).getTime() + p_milliseconds;        
    do { cur = (new Date()).getTime(); } while (cur < end);
}

kweet niet of die zo precies is, maar je kunt het proberen.

[Verwijderd]

idd, dat werkt dus, zeer kool, bedankt

[Verwijderd]

je kunt

code:

Thread.sleep(long millis);

Gebruiken, deze zit in java.lang.Thread en wordt automatisch geladen.

[.oisyn]

Op maandag 31 december 2001 17:59 schreef marcusk het volgende:
1 milliseconde? das niet veel.

code:

private void wait(int p_milliseconds)
{
    long cur, end = (new Date()).getTime() + p_milliseconds;
    do { cur = (new Date()).getTime(); } while (cur < end);
}

kweet niet of die zo precies is, maar je kunt het proberen.

das weel heel erg inefficient, aangezien je elke iteratie een nieuw Date object aanmaakt. Dan kun je beter gebruik maken van System.currentTimeMillis (). Maar dan is de oplossing die Wiebra gaf nog beter, aangezien je programma tijdens het wachten dan geen processortijd inneemt

[marcusk]

ja, ok, das waar

[Goldme]

Op maandag 31 december 2001 17:59 schreef marcusk het volgende:
1 milliseconde? das niet veel.

code:

private void wait(int p_milliseconds)
{
    long cur, end = (new Date()).getTime() + p_milliseconds;        
    do { cur = (new Date()).getTime(); } while (cur < end);
}

kweet niet of die zo precies is, maar je kunt het proberen.

dat heet actief wachten(neemt processortijd onnodig in). Je kan beter een thread van je object maken(als het mogelijk is) en die laten slapen/waiten. Ik denk dat je leraar over dat actief wachten kan gaan vallen aangezien het erg inefficient is.

[Verwijderd]

Op maandag 31 december 2001 17:59 schreef marcusk het volgende:
1 milliseconde? das niet veel.

code:

private void wait(int p_milliseconds)
{
    long cur, end = (new Date()).getTime() + p_milliseconds;        
    do { cur = (new Date()).getTime(); } while (cur < end);
}

kweet niet of die zo precies is, maar je kunt het proberen.

Op deze manier kan het nooit het nooit erg precies werken, want zo gebruik je de gewone computerklok(die de tijd op de pc bijhoudt), en das een kwartskristal die maar 18.6 pulsen per seconde geeft, niet al te precies dus...

Die manier met sleep(long millisecs)gebruikt daarentegen de microtimer, en is dus wel even iets preciezer...

[Onno]

Op dinsdag 01 januari 2002 12:23 schreef minne het volgende:
Op deze manier kan het nooit het nooit erg precies werken, want zo gebruik je de gewone computerklok(die de tijd op de pc bijhoudt), en das een kwartskristal die maar 18.6 pulsen per seconde geeft, niet al te precies dus...

Het is om te beginnen 18.2 (omdat je dan na 2^16 tikken precies een uur verder bent), en verder is die frequentie gewoon programmeerbaar. Het ding wat er verantwoordelijk voor is heet niet voor niets Programmable Interval Timer. Het maximum ligt iets boven de 1MHz (diezelfde 18.2, maal 2^16), en dat is ruim voldoende voor milliseconden.

En verder is Date() gewoon nauwkeuriger dan je zegt, dat had je zo zelf kunnen testen.

code:

    for (int i=0;i<1000;i++)
    {
    System.out.println(new Date().getTime());
    }

Levert zoiets op bij mij:

code:

1009884881453
1009884881453
1009884881468
1009884881468
...
1009884881468
1009884881468
1009884881484
1009884881484
...
1009884881484
1009884881484
1009884881500
1009884881500

Lijkt een nauwkeurigheid van ongeveer 16ms te zijn, en dat is meer dan die 18.2Hz.

(de precieze resolutie is overigens OS/JVM specifiek lijkt me... <- is zeker zo, onder Linux is ie bij mij gewoon op de milliseconde nauwkeurig)

[Verwijderd]

public void slaap( int msec ) {
try{ Thread.sleep( msec );
}
catch( InterruptedException e ) {}
}

En dan een pauze met
slaap(150);

voor 150 msec !

[vinnux]

[java]
Thread.sleep(1);
[/java]

Dit kun je het best gebruiken. Maar je zult merken dat ie nooit precies 1ms slaapt. Dit kan zelf heel erg verschillen. Het hangt namelijk van het os af wanneer het programma weer processortijd krijgt. Dus als ie pas na 3 ms weer processortijd krijgt heeft ie dus meer dan 1 ms geslapen.

Nu is mijn vraag, waarovoor heb je het nodig ?
Als je zulke korte slaaptijden hebt is er vast wel een andere oplossing te bedenken.

[Goldme]

kun je aan een java-proces geen priority toekennen of de processortijd voor korte tijd overnemen(semaphoren?)? zo voorkom je dat de OS andere processen gaat inplannen die deze proces gaan ophouden, misschien langer dan die milliseconde.

En dat buisy waiting hierboven is niet toereikend aangezien het proces verbroken kan worden tijdens het uitvoeren van die wachtopdracht.