Newsgroup: it.comp.java
Titolo: loops e CPU

Lo so che ho scoperto l'acqua calda, ma ho appena scoperto che se faccio
girare una roba del genere:
public class Test {
  public static void main(String args[]) {
    double rnd = 0 ;
    for (int i=0; i<1000000; i++) {
      rnd = java.lang.Math.random() ;
      System.out.println(i) ;
    }
  }
}
la CPU libera in breve tempo va allo 0%.
Come posso fare per gestire loop molto grandi senza ammazzare il
sistema? Leggere un file di testo di 1.000.000 di righe e fare qualcosa
con _ogni_ riga per esempio?
Grazie in anticipo e scusate l'argomento terra-terra.
-- 
Cristian Veronesi ><((((º> 
http://www.crpa.it
General rule for life: avoid pain for as long as possible
unless doing so will ultimately cause more pain.

 con _ogni_ riga per esempio?
Eh beh ci credo che mandi a 0 la CPU libera. Del resto, se non c'è nulla che
giri in background, non ci sono task a priorità più alta o uguale,
giustamente il sistema concederà tutta la CPU al tuo programma. Se però stai
rosicando perchè si sentono male gli MP3 per questo ;) potresti provare a
infilare una chiamata a sleep() con un intervallo di tempo moooolto piccolo
per concedere un po' di CPU al resto dei programmi. Non sarà elegante,
chiamalo multitasking cooperativo... ;)
Ciao,
 Stefano
----------
"X WindowSSS, teSSSoro mio... lo odieremo per SSSempre"
Bill Gollum
----------

 
sul mio K6-II 266MHz, linux RH 6.1, SUN jdk1.2.2: l'utilizzo del
processore da parte del programma java non supera il 36%. Togliendo la
riga con il println -come era prevedibile- aumenta, e si attesta intorno
al 70%. Cambiando il tutto in un while( true ) {} la situazione
peggiora, ma non di molto: sotto l'80%.
cmq si, su un sistema che gestisce i processi utente "un po` meno bene",
come ad esempio win, una Thread.sleep(), o una Thread.yield() (che in
teoria e` la scelta piu` giusta, ma devo essere sincero: non l'ho mai
usata ;-) e` l'unica soluzione per dare anche agli altri task a minore
priorita` una possibilita` di esecuzione.
-- 
Ciao,  |  I play Russian roulette everyday, a man's sport,
Matteo |  With a bullet called life, yeah called life, (SUGAR)

> 
M> sul mio K6-II 266MHz, linux RH 6.1, SUN jdk1.2.2: l'utilizzo del
M> processore da parte del programma java non supera il 36%.
Merito dello scheduler di Linux :)
M> Cambiando il tutto in un while( true ) {} la situazione
M> peggiora, ma non di molto: sotto l'80%.
Cavoli, aumenta l'efficenza con un salto incondizionato!
M> cmq si, su un sistema che gestisce i processi utente "un po` meno bene",
M> come ad esempio win, una Thread.sleep(), o una Thread.yield() (che in
M> teoria e` la scelta piu` giusta, ma devo essere sincero: non l'ho mai
M> usata ;-) e` l'unica soluzione per dare anche agli altri task a minore
M> priorita` una possibilita` di esecuzione.
Credo funzioni solo la Sleep per  i thread (di sistema, non di Java) a
priorità più  bassa. In  Windows (che  usa code di  priorità e  non un
meccanismo a penalizzazione)  il thread Java che fa  una yeld molla la
JCPU e probabilmente  la riprende subito (ma per  Windows la CPU resta
alla  JVM) che  si termina  il suo  timeslice. Quando  lo ha  finito è
possibile che la CPU le ritorni. Se poi la JVM ha il boost di priorità
dei thread legati alla finestra col focus...
\begin{echelon}
North Korea Uzi FSF quiche munitions Serbian counter-intelligence
Honduras DES Semtex colonel genetic SDI FBI Mossad
\end{echelon}
\begin{avviso}
 
Attenzione: Leggersi lo header riguardo al mio e-mail!
Warning: read header for infos about my e-mail.
\end{avviso}
+----------------------------------------------------------------+
| Gian Uberto Lauri * "So, are you working on fixing that bug    |
| 
sa...@eng.it
      *  *now* or leaving it until later ?" - YES  |
+----------------------------------------------------------------+

 chiamalo multitasking cooperativo... ;)
Innanzitutto grazie per la risposta.
Il problema è che il mio applicativo loopante si auto-incricca, nel
senso che impiega un tempo x per i primi 100000 giri, un tempo x*2 per i
successivi 100000, un tempo x*3 per i successivi e così via fino a
saturare la CPU al punto di bloccarsi o quasi (i numeri indicati sono
soltanto a titolo di esempio).
L'applicativo in questione apre uno ZIP contenente uno o più file di
testo a lunghezza fissa e per ogni riga si costruisce un INSERT SQL e lo
spara su di un database Oracle. Tutte le volte creo uno statement, lo
eseguo, poi lo chiudo e metto pure il puntatore a null. Ogni 64 record
faccio un commit e richiamo il garbage collector. Ovunque sono stato
attentissimo a non fare proliferare gli oggetti, mettendo sempre a null
quelli che non utilizzo più e usando la Stringbuffer ovunque possibile.
C'è un utility Oracle chiamata SQL*Loader che fa praticamente la stessa
cosa ma senza saturare la CPU.
Dove ho sbagliato? Pensi che la chiamata a sleep() al momento del
richiamo del garbage collector possa risolvere la cosa?
Ciao e grazie di nuovo, Cris


[...]
Hm. Com'e' la tua insert? Quel tipo di progressione si ha, generalmente, su 
statement che implicano un lookup su tabella (tipo un insert che usa MAX(..), 
SUM(..) etc).
-- 
God is Real, unless declared Integer.
ObjectZone - 
http://space.tin.it/computer/csadun

 SUM(..) etc).
Banalissima "INSERT INTO pippo(a,b,c) VALUES (1,2,3)"
Papale papale.
Ciao, Cris
