problema con gli interrupt

[lio.b]

Buongiorno,
ho realizzato una struttura (un array) bloccante che ha questi 2 metodi:

    public  void add(File f,int j){
        synchronized(shared){
        shared[j] = f;        
        shared.notifyAll();
         }
    }
    public File get(int index) throws InterruptedException{
        synchronized(shared){
           while(shared[i]==null)
               shared.wait();              
            return shared[index];
        }

Ho un thread che richiama il metodo get:

try{
shared.get(int i)
/*altre operazione tra cui lancio di un altro thread */
sleep(5000);
}
catch(InterruptedExcpetion e){
return;
}
Ho notato che quando invio un interrupt a questo thread la funzione get non è più bloccante, infatti mi legge un file vuoto. Come mai visto che quando catturo l'eccezione gli dico di fare solo un return?

[lio.b]

Il problema l'ho capito...nel senso che quando mando un interrupt al thread si sblocca anche la wait get del . Se così fosse mi chiedevo se posso fare in modo che l'interrupt mi lascia soltanto la get bloccante...se l'elemento che va a leggere è vuoto ovviamente.
Se qualcuno cortesemente mi può dare una dritta perchè è l'unica cosa che non funziona del progetto (che finisce con questo metodo) altrimenti ho sbagliato tutta l'impostazione se non riesco a risolvere questo e ciò implica rincominciare da capo.

[andbin]

Originariamente inviato da lio.b
nel senso che quando mando un interrupt al thread si sblocca anche la wait get del .

Sì, infatti (lo dice pure bene la documentazione di wait() di Object).

Originariamente inviato da lio.b
mi chiedevo se posso fare in modo che l'interrupt mi lascia soltanto la get bloccante...se l'elemento che va a leggere è vuoto ovviamente.

Cioè vuoi che il get() resti bloccato nella wait e non "esca" con InterruptedException se interrompi il thread che sta facendo la get()???

Allora metti dentro il while un try (con dentro la wait()) con un catch ("vuoto") che cattura InterruptedException. Chiaramente il metodo get non ha più senso che dichiari la InterruptedException.

[lio.b]

esattemente! a quel punto non ha più senso! Mi serve che la wait è bloccante nella struttura ma quando la richiamo nel thread non si possa sbloccare con un interrupt...è possibile? O una cosa del tipo: se l'interrupt viene invocato dl metodo xxx non sbloccarti

[andbin]

Originariamente inviato da lio.b
esattemente! a quel punto non ha più senso! Mi serve che la wait è bloccante nella struttura ma quando la richiamo nel thread non si possa sbloccare con un interrupt...è possibile? O una cosa del tipo: se l'interrupt viene invocato dl metodo xxx non sbloccarti

Ma l'ho detto prima. Metti nel while il try/catch. Il catch è vuoto, quando cattura InterruptedException non fa nulla e il ciclo while si ripete.
Impedire a livello più interno che la wait() non si sblocchi lanciando InterruptedException ovviamente non è possibile .... è stato stabilito così.

[lio.b]

Se invece tolgo il bloccaggio e nel thread metto una:
while(get(i)==null){
//non fare niente
}
ottengo lo stesso effetto e a me va bene. Solo che, facendo riferimento al thread postato in precedenza, nel momento che invio l'interrupt il thread(credo) si possa fermare solo sulla sleep giusto? Per cui rischio che fino a quando non esco dal while il thread non si blocca?

try{
while(shared.get(int i)==null)
//non fare nulla

/*altre operazione tra cui lancio di un altro thread */
sleep(5000);
}
catch(InterruptedExcpetion e){
return;
}

[andbin]

Originariamente inviato da lio.b
Se invece tolgo il bloccaggio e nel thread metto una:
while(get(i)==null){
//non fare niente
}
ottengo lo stesso effetto e a me va bene.

Non ha granché senso. E oltretutto "sprecheresti" solo prezioso tempo di CPU.

Originariamente inviato da lio.b
Solo che, facendo riferimento al thread postato in precedenza, nel momento che invio l'interrupt il thread(credo) si possa fermare solo sulla sleep giusto? Per cui rischio che fino a quando non esco dal while il thread non si blocca?

Ammettiamo che tu togli il wait() e quindi fai solo un ciclo "vuoto" per aspettare .... se invochi interrupt() sul thread .... non succede nulla!!! Perché l'interrupt in realtà è da gestire in modo "cooperativo" (setta solo un flag) ed è gestito in modo "speciale" solo in casi di wait()/join()/sleep() e altri casi di I/O bloccante.
Se stai ciclando solo con la CPU .... non succede un bel nulla!! Viene settato solo il flag di "interrotto" ma tu non esci da nessuna parte!!!

Se leggessi la documentazione di interrupt()???

[lio.b]

Ti chiedo scusa, l'ho letta la documentazione, per questo non riesco a capire una cosa. Il codice completo del thread(del run() per l'esattezza), chiamto MainThread è questo:

        while(courrent<dim){
//            foto = new JLabel();
            
            try{
            ImageIcon i = new ImageIcon(immagini.get(courrent).getAbsolutePath());
            foto.setIcon(i);
            courview = courrent;
            courrent++;
            if(courrent>file.size()-1)
                break;
            if(immagini.get(courrent)==null){
            ThreadTransferFile c = new ThreadTransferFile(file.get(courrent),name.get(courrent),immagini,courrent);
            c.start();}
            sleep(5000);
            }
            catch(InterruptedException e){
                return;
            }

        }

Ora,nel 90% dei casi, quando invio l'interrupt mi trovo bloccato sulla sleep e non sulla get.
Catturo l'eccezione ed eseguo un return quindi esco dal metodo. Perchè mi va a leggere l'immagine nell'array immagini (che non c'è)se quando mando l'interrupt deve uscire dal metodo?
Proprio non riesco a capirlo

[lio.b]

Dov'è che sbaglio?

[lio.b]

In poche parole, è come se quando mando l'interrupt la wait che ho sulla get va a farsi fottere anche se ( ne sono certo) il valore che questa restituisce è null, contrariamente a quanto ho scritto io.
Qualcuno sa dirmi qualcosa?
Grazie