[JAVA]: Rilanciare eccezioni ricevute

[doraemon83]

Salve a tutti... ho un problema con le eccezioni.
devo usare una sleep() della classe Thread... e fin qui nessun problema. Essa lancia l'eccezione InterruptedException e quindi mi basta mettere la sleep() in un blocco try-catch.
Il problema è che vorrei che se arriva tale eccezione essa venga reinviata alla funzione chiamante, che penso si faccia con un throw all'interno del catch.

while (true) {
			try {
				sleep(1000);
			}
			catch(InterruptedException e) {
                              System.out.println("Interruzione ricevuta");
			      throw e;
                        }

questo è il codice che ho usato. Il problema è che sulla riga del throw, eclipse mi da il seguente errore :
Unhandled Exception type InterruptedException

eppure l'eccezione l'ho catchata... come si risolve questo problema?

[floyd]

il metodo che contiene quel codice deve essere dichiarato con un throws
public void nome(...) throws InterruptedException

[andbin]

Originariamente inviato da doraemon83
Il problema è che sulla riga del throw, eclipse mi da il seguente errore :
Unhandled Exception type InterruptedException

InterruptedException è una eccezione "checked". Se il tuo codice (ri)lancia questa eccezione, il metodo deve essere dichiarato:
... nomemetodo (...) throws InterruptedException

[doraemon83]

Ho provato come avete suggerito voi, ma questa sleep si trova nel metodo run di un thread, e il metodo run non prevede clausole throws.

praticamente... sto facendo l'esercizio uscito all'esame ieri.
Devo realizzare un thread chiamato Interruptor che accetta un thread e il numero di secondi, e interrompa l'esecuzione del thread ricevuto come parametro dopo che sono passati tanti secondi quanto quelli passati come argomento. Il codice di questo thread è :

package threads;

public class Interruptor extends Thread {
	private Thread t;
	private int seconds;
	
	public Interruptor(String name,Thread t,int seconds) {
		super(name);
		this.t=t;
		this.seconds=seconds;
		start();
	}
	
	public void run() {
		try {
			sleep(seconds*1000);
		}
		catch(InterruptedException e) {}
		t.interrupt();
	}
}

Sto provando questo codice con un altro thread che avevo creato come esempio e che possiede quella sleep(). Soltanto che siccome c'è il catch dell'eccezione, essa viene ingnorata dal mio thread di prova.
Non posso fare

public void run() throws InterruptedException

che da errore, e non posso neppure inserire il throw all'interno del catch.... come fare? Vorrei se possibile una metodo che funzioni sempre con qualsiasi thread che voglio terminare ma che utilizzi comunque interrupt()

[andbin]

Originariamente inviato da doraemon83
Non posso fare

public void run() throws InterruptedException

che da errore

Ah beh, certo che così dà errore. Il metodo run che hai messo è un override e un metodo in override non può lanciare eccezioni "checked" che siano "nuove" o più "larghe" rispetto al metodo di cui è stato fatto l'override!!

Poi non vorrei dire una cavolata ... ma se anche riuscissi a lanciare eccezioni al di fuori del run(), a chi andrebbero??? Alla JVM mi sembra. Non so se mi sono spiegato ... la documentazione dice:

public void start()

Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.

È la JVM a chiamare il metodo run(), quindi non ha molto senso rilanciare una eccezione al di fuori del run!

[doraemon83]

Ma se una eccezione non viene mai catturata (neppure dal main) non arriva comunque alla JVM?
Cmq visto che cosi non si può come si potrebbe fare per terminare un thread che cattura l'eccezione InterruptedException?

[floyd]

public void run() {
  try {
    sleep(seconds*1000);
  } catch(InterruptedException e) {
    return;
  }
  t.interrupt();
}

col return il thread termina

[doraemon83]

E non si può terminare un thread anche se questo cattura l'eccezione e non fa return?

[floyd]

il thread termina alla fine del run
come far finire il metodo run lo decidi tu, variabili da controllare, try catch, condizioni

[LeleFT]

Un thread termina quando il suo metodo run() termina (non è necessario un return, basta che il metodo finisca!).
Se tu "non vuoi" catturare l'eccezione, basta che non fai far niente al blocco catch():

try {
   ...
} catch (InterruptedException ie) {}

Ciao.