[Java]Perchè non riesco mai a fermare un Thread

[tonytalk]

Io, forse sono arrivato al limite e non ci stoo capendo più niente,
Creo un Thread al volo chiamato t, e il thread corrente lo faccio dormire.

Ora la mia intenzione è bloccare volontariamente il thread t e quindi farlo rimuovere dal thred corrente quando esso si risveglia

In pratica non ho nessun errore ma il thread t non si ferma e continua a fare i cavolacci suoi
Come faccio a FERMARLOOOOOOOOOOOOO

Grazie

//Creo un Thread al volo identificato da t

Thread t;
timeout=null;
(t=new Thread(){
public void run(){
for(Enumeration e = h.elements(); e.hasMoreElements(){
timeout=(Send_Synchronized)e.nextElement() ;
timeout.invia(myThread);
}
timeout=null;
}}).start();

//Blocco il thread corrente
try {
Thread.currentThread().sleep(50);
if(timeout!=null){
}
}catch (Exception ex) { System.out.println("Eccezione");}

if(timeout!=null){

System.out.println("Il thread è bloccato allora lo elimino");

//Ho provato con nessun risultato
t.interrupt();

//Ho provato
t.checAccess()
t.interrupt()

//Ho provato ma non si ferma per niente
t.wait()

//ho provato anche il metodo deprecato suspend() e nessun risultato
}

[lelefante]

Ma perche' complicarsi la vita in questo modo?!?
KISS non ti dice niente, vero?
E soprattutto... perche' complicare la vita agli altri? Visto che c'e' la possibilita' di formattare il codice, perche' non usarla?

Al di la' di questo (lo so, oggi sono polemico, non ce l'ho con te) ti consiglierei:

1)Evita una classe anonima, scrivi la classe esplicita e fai tutti i test necessari, eventualmente la rendi anonima quando sei sicuro di quello che fai.

2)Implementa tu un metodo che fermi il thread in modo esplicito.

3)Metti qualche System.out dentro a run() in modo da vedere cosa c'e' in esecuzione e se/quando esce dal metodo.

Note:
wait() si puo' chiamare solo nel caso in cui il thread chiamante possiede il lock monitor dell'oggetto di cui si invoca wait(), e quindi da un metodo sincronizzato

interrupt() non interrompe un thread, ma ne attiva il flag. Se tu non controlli il flag di interruzione, il metodo non serve a nulla

[tonytalk]

Kiss ..non ti vedo da un bel pò se non sbaglio, certo che ti potresti collegare e potresti darmi una mano via chat

Cmq andavo molto di fretta e avevo cercato di capire la formattazione ma non ho mica capito come si fa qua!!! devo scrivere io in Html???

Tornando a noi il mio problema è il seguente...ho un thread-1 che lancia un Thread-2

Devi ipotizzare che il thread-2 può, in circostanze non controllabili da me, restare bloccato su una istruzione write su un socket. (Maggiori chiarimenti li puoi avere dall'altro mio posto [java]problemi con la classe socket)

Il mio problema sta nel fatto che metto a riposare il Thread-1 (diciamo una join(3secondi) ) se si svelia e il Thread-2 non ha finito io devo semplicemente eliminare, bloccare, togliere e cia siamo capiti :tongue: il Thread-2

Ma se il Thread-2 è bloccato io non posso fare niente???? perchè sono giunto a questa conclusione io!!!

Oggiho finalmente in mano un nuovo manuale sul java (il mio ancora mi dava in vigore i metodi deprecati , spero di colmare le lacune sui Thread

Ciao ciao

[lelefante]

1) KISS = Keep It Simple, Stupid!
e' una regola base che si legge sui manuali di programmazione (non necessariamente in tutti, diciamo che qualche spiritoso ha tirato fuori questa cosa) :gren:.

2) Per formattare il codice lo devi inserire tra i tag [ CODE ] e [ /CODE ] (senza spazi), cosi' rendi il codice piu' chiaro a chi lo deve leggere.

3) Per il tuo problema ti consiglio di dare un'occhiata al package java.nio, in cui ci sono gli stream non bloccanti. Se un thread ti si blocca su un metodo write() non hai la possibilita' di forzarne la chiusura, devi implementare tu un modo in cui continui a controllare un flag. Se questo flag e' attivato, il thread esce da run() e cosi' muore.

[alexmaz]

Originariamente inviato da lelefante


interrupt() non interrompe un thread, ma ne attiva il flag. Se tu non controlli il flag di interruzione, il metodo non serve a nulla

Interrupt interrompe il thread...

questa è una classe derivata da thread e che funziona, interrompere un thread è semplice, lo vedi nel metodo ferma, che chiaramente viene chiamato da "fuori"...

public class Centro extends java.lang.Thread {

    /*La coda dove vengono estratti, autorizzati e inseriti i messaggi */
    private ICoda coda;

    private String nome;

    private int condizione = 1;

    public Centro(ICoda coda, String nome) {
        this.coda = coda;
        this.nome = nome;
    }

    /*Restituisce il nome dell'oggetto */
    public String nome(){
      return this.nome;
    }

    public void ferma(){
      condizione = 0;
      this.interrupt();
    }

    public void run() {
        //IMessaggio msg;
        while(condizione == 1) {
              Object msg = coda.estrai();
              if (msg instanceof IMessaggio){
                IMessaggio messaggio = (IMessaggio) msg;
                coda.autorizzaMessaggio(messaggio);
              }
        }
    }

}

[lelefante]

Prova a togliere l'istruzione condizione = 0 nel metodo ferma() e vedrai che non basta chiamare interrupt() per femare il thread.
Se vuoi ti posto un esempio:

import java.net.*;
import java.io.*;

public class Esempio extends Thread {
    private boolean run = true;
    private String msg = "";
    private int i = 0;
	
    public void ferma() {
    	run = false;
    }
    
    public void run() {
    	try {
	    while(run) {
	        System.out.print(++i + " ");
	    }
	} catch(Exception e) { System.out.println(e); }
        System.out.println("Esco da run");
    }
    
    public static void main(String args[]) {
    	Esempio e = new Esempio();
    	e.start();
    	new Controllo(e);
    }
}

class Controllo extends Thread {
	
	private Esempio esempio;
	
	Controllo(Esempio e) {
		esempio = e;
		start();
	}
	
	public void run() {
		try {
			Thread.sleep(2000);
		} catch(Exception e) { System.out.println(e); }
		esempio.interrupt();
		System.out.println("Chiamato interrupt");
		if(esempio.isAlive())
			System.out.println("Il thread e' ancora attivo");
		try {
			Thread.sleep(5000);
		} catch(Exception e) { System.out.println(e); }
		esempio.ferma();
		System.out.println("Chiamato ferma");
		System.out.println("Esempio fermato");
	}
}

L'uscita da run e' determinato solo dalla variabile di controllo run.
In realta' il metodo interrupt() si comporta in maniera analoga: imposta a true lo stato di una variabile interna, che puo' essere letta tramite i metodi interrupted() o isInterrupted().

[alexmaz]

Originariamente inviato da lelefante
Prova a togliere l'istruzione condizione = 0 nel metodo ferma() e vedrai che non basta chiamare interrupt() per femare il thread.
Se vuoi ti posto un esempio:

L'uscita da run e' determinato solo dalla variabile di controllo run.
In realta' il metodo interrupt() si comporta in maniera analoga: imposta a true lo stato di una variabile interna, che puo' essere letta tramite i metodi interrupted() o isInterrupted().

scusa, hai ragione tu... interrupt() manda solo un segnaleal thread... è parecchio che non uso Java e ho postato un po' a caso

[tonytalk]

Grazie per l'aiuto, siete stati molto disponibili.
Scusami lelefante ma, c'è un KISS che gioca sul mio sito, e avvolte mi aiutato a superare alcuni problemi in java.

Avevo postato sul mio forum un link a questa discussione, ero convito che fosse lui a rispondermi

Darò una occhiata al pakage perchè cmq io non ho modo di controllare un flag, sono fermo sulla write.

Copierò il codice scritto da voi e lo terro ben custodito per ogni evenienza :adhone: tanto mi ricordo che ho sempre avuto problemmi nel fermare i Thread

Grazie ancora

PS cmq la prima "bozza di" soluzione che ho apportato nel gioco funzionaaaaaaaaaaaaaaaa sono al settimo cielo, Il server funziona da 3 giorni (in pratica lascio bloccato quel thred fino a quado non viene sollevata l'eccezione)

:quote: :quote: :quote:

Ora mi merito un lungo