Newsgroup: it.comp.java
Titolo: Consiglio operativo

Ciao a tutti,
ho il seguente problema da risolvere e spero che qualcuno possa darmi qualche consiglio utile.
Non sto a spiegare perche' sono arrivato a questo punto ma in sostanza ho una 
tabella "coda" dove vengono inseriti una serie di record in sequenza che identificano 
delle classi da eseguire con i relativi aprametri da passare, ad esempio:
idcoda|oggetto|parametri|status
1|my.package.aaa.ImportData|3|0
2|my.package.aaa.Transform|7 4|0
3|my.package.aaa.ImportData|2|0
Poi ho un servizio(sotto supervise) che fa una select in quella tabella, esegue la prima
classe con status = 0 una volta terminato aggiorna lo status a 1 e muore.
Supervise ritura su il servizio che rifa' lo stesso giro.
Ora ho la necessita di trasformare il sistema, spero con poco sforzo, per fare in 
modo che il processo esegua sino a un massimo di 5 elementi in coda per volta in modo dinamico 
e non a blocchi...cerco di spiegarmi.
se ho 1000 elementi in coda non devo prendere i primi 5, processarli e procedere con 
i prossimi 5.
Visto che ogni elemento ha un tempo di esecuzione variabile voglio mantenere sempre attive 
5 esecuzioni, quindi quello che vorrei ottenere e' questo:
prendo le prime 5 appena se ne libera una aggiungo un altro elemento all'esecuzione, 
se se ne liberano 2 prendo altri due elementi, sempre sino ad un massimo di 5.
Vorrei evitare di utilizzare i thread e stavo pensando a quartz, qualcuno ha 
esperienze di questo genere? 
Avete soluzioni/idee alternative?
Ciao,
crx

 Avete soluzioni/idee alternative?
Quartz e' una possibilita', ma per quello che ti serve fa anche
troppo. Sono convinto che con lo stesso tempo che ti servirebbe ad
imparare ad utilizzare quartz, riusciresti a risolvere il problema
utilizzando manualmente i thread.
Il tuo problema e' semplice e non richiede una sofisticata conoscenza
dei thread di java per risolverlo efficacemente. Diciamo che ci sono 2
possibili soluzioni: una davvero elegante ma un po' complicata per chi
non ha mai avuto esperienze del genere, e una semplice ed accessibile
a chiunque (anche se fa un po' storcere il naso ai puristi come
me :P ). Ti spieghero' quest'ultima soluzione.
Il main() del tuo programma potrebbe essere impostato all'incirca in
questo modo:
Thread[] services = new Thread[5];
for( ;; ){
  Thread.sleep(10);
  for( int i = 0; i < services.length; ++i ){
    if( services[i] == null || !services[i].isAlive() ){
      services[i] = new Thread( new MyService() );
      services[i].start();
    }
  }
}
In pratica definisci 5 slot per l'esecuzione dei tuoi servizi e
continui a controllare questo array (ogni 10 millisecondi, in modo da
non sprecare troppi cicli di clock) in attesa che si liberi uno slot.
Ogni qualvolta un servizio finisce l'esecuzione (!Thread.isAlive()) ne
crei uno nuovo e lo esegui.
L'unico requisito e' che il tuo oggetto MyService implementi
l'interfaccia Runnable definendo il metodo run(), dove metterai tutta
la tua logica applicativa.
Ci sono modi per migliorare l'algoritmo e modi per rifarlo molto
meglio, ma anche lasciato cosi' puo' funzionare.
--
SoulSpirit

 crei uno nuovo e lo esegui.
Ciao SoulSpirit,
grazie per il consiglio, avevo gia' fatto qualche prova in questo senso
con esito positivo ma mi ero orientato su quartz perche', guardando al
futuro, mi sembrava piu' completo.
Ma visto che la cosa deve essere messa in produzione velocemente mi sa che
utilizzero' i thread a manina.
Grazie mille,
crx