Puoi creare un secondo thread concorrente al primo che invoca un tuo metodo
Ti passo la soluzione che usa una classe mia :
La tua classe dovrebbe implementare
- Codice: Seleziona tutto
public interface Tickable
{
/** Procedura richiamata ad intervalli approssimativamente regolari */
public void timeTick();
}
Con la classe seguente puoi gestire il secondo thread :
- Codice: Seleziona tutto
public class TimeController implements Runnable
{
/** specifica il ritardo tra una chiamata e l'altra in millisecondi */
public int m_nDelay;
/** il Tickable che verrà gestito da questo TimeController */
private Tickable m_Tick;
/** il Thread che gestisce questo TimeController */
private Thread m_thread;
/** variabile che indica se il TimeController deve continuare a eseguire.
Poiché un thread esegue solo letture e l'altro solo scritture, non è necessaria sincronizzazione. */
private boolean m_keepAlive = false;
/** variabile che indica il numero di istanza del TimeController */
private static int m_nHynstNumber = 0;
/**
* Costruisce un nuovo TimeController
* @param p_Tick il Tickable su cui richiamare il metodo timeTick
* @param delay il delay tra un frame e l'altro in millisecondi
*/
public TimeController (Tickable p_Tick, int delay)
{
m_Tick = p_Tick;
m_nDelay = delay;
}
/**
* Costruisce un nuovo TimeController con un delay fisso di 30ms
* @param p_Tick il Tickable su cui richiamare il metodo timeTick
*/
public TimeController (Tickable p_Tick)
{
m_Tick = p_Tick;
m_nDelay = 30;
}
/**
* Avvia il TimeController
da questo momento il metodo timeTick dell'oggetto Tickable associato potrebbe essere richiamato
*/
public void start()
{
if (m_keepAlive) return;
m_keepAlive = true;
m_thread = new Thread(this, "TimeCtrl" + m_nHynstNumber);
m_nHynstNumber++;
m_thread.start();
}
/**
* Procedura principale del TimeController : non dovrebbe essere richiamata da programma..
*/
public void run()
{
while (m_keepAlive) {
m_Tick.timeTick();
System.out.print(".");
try { Thread.sleep(m_nDelay); }
catch(InterruptedException e) { System.out.println("Thread interrotto!");}
}
}
/**
* Termina (con attesa) il thread del TimeController
*/
public void stop()
{
if (!m_keepAlive) return;
m_keepAlive = false;
try {
m_thread.join();
} catch(InterruptedException e) { System.out.println("Thread interrotto!");}
}
/**
* Restituisce true se il TimeController sta girando, false altrimenti.
@returns True se il TimeController è attivo, false altrimenti.
*/
public boolean isAlive ()
{
return m_keepAlive;
}
}
Semplicemente fai :
- Codice: Seleziona tutto
// variabili :
private TimeController m_timeCtrl;
private int m_elapsedTime;
// nel costruttore :
m_timeCtrl = new TimeController(this); // un timetick ogni 30ms
// metodo :
public void timeTick()
{
m_elapsedTime += 30;
if (m_elapsedTime >= 2000)
{
stopWaveRecording();
m_timeCtrl.stop();
}
}
// infine dove inizi la registrazione fai :
m_timeCtrl.start();
Potresti anche costruire direttamente l'oggetto con Delay = 2000, ma con un intervallo di 30ms dovresti essere più al sicuro da effetti tipo "venire chiamato una volta di troppo all'inizio" o "un tick piu tardi" ... A meno che per te faccia davvero differenza se è 1970ms o 2030ms in tal caso forse Java non è il linguaggio adatto
Tutto questo naturalmente se mi ricordo bene.. sono classi che avevo fatto per l'esame di Java di qualche anno fa all'uni
Era un gioco tipo DynaBlaster e puoi trovare gioco e sorgenti in
http://digilander.libero.it/xanathar/jbomb.zip . Magari ti sono d'aiuto per altro
[ho ripreso Java da pochi giorni per provare a fare un gioco per cellulari quindi non mi ricordo granchè.. più che probabile che ho scritto boiate!]