Stoppare un thread

[Donovant]

A parte il fatto di mettere il "wait()" in un blocco try{...}catch(){...}, ma nel:

synchronized (this) {
            banca.operazione(modifica);
            while (sospendi) {
                wait();
            }
}

"sospendi" è false, e non diventerà mai "true" (non vorrei dire cagate), perchè dal metodo "run" della classe Runnable non vai a leggere la variabile (privata) "sospendi"...
ma portesti mettere in "wait", direttamente nel metodo "operazione(int s)"

synchronized public void operazione(int s) {
        if (saldo + s < 0) {
            System.out.println("Impossibile effettuare l'addebito " + s);
            try{ wait(); }catch( InterruptedException ie ){}//qui puoi lasciare vuoto

        } else {
            saldo += s;
            System.out.println("Modifica di " + s + " effettuata, Il tuo saldo è: " + saldo);
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                System.out.println("Errore " + e.getMessage());
            }
        }
    }

In questo modo si blocca come vorresti tu, ma poi il programma va in blocco, deadlock, chiamalo come vuoi e resterà in quella condizione, a meno che ci sia qualche altro "oggetto" che lo risveglierà, attenzione però, il risveglio non può essere mirato, certo che se hai solo una oggetto Banca2 in blocco puoi usare notify();, ma se ce ne sono di più per la programmazione concorrenziale dovresti usare notifyAll(); e verificare con un "while", chi deve o meno rientrare nello stato di blocco.

Spero di essere stato chiaro e di aver capito quello che ti serviva

[fermat]

purtroppo nn funziona lo stesso.
portare il tutto nella classe del metodo run() è un pò casino.
grazie mille lo stesso per l'aiuto!!

[fermat]

Originariamente inviato da Donovant
A parte il fatto di mettere il "wait()" in un blocco try{...}catch(){...}, ma nel:

synchronized (this) {
            banca.operazione(modifica);
            while (sospendi) {
                wait();
            }
}

"sospendi" è false, e non diventerà mai "true" (non vorrei dire cagate), perchè dal metodo "run" della classe Runnable non vai a leggere la variabile (privata) "sospendi"...
ma portesti mettere in "wait", direttamente nel metodo "operazione(int s)"

synchronized public void operazione(int s) {
        if (saldo + s < 0) {
            System.out.println("Impossibile effettuare l'addebito " + s);
            try{ wait(); }catch( InterruptedException ie ){}//qui puoi lasciare vuoto

        } else {
            saldo += s;
            System.out.println("Modifica di " + s + " effettuata, Il tuo saldo è: " + saldo);
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                System.out.println("Errore " + e.getMessage());
            }
        }
    }

In questo modo si blocca come vorresti tu, ma poi il programma va in blocco, deadlock, chiamalo come vuoi e resterà in quella condizione, a meno che ci sia qualche altro "oggetto" che lo risveglierà, attenzione però, il risveglio non può essere mirato, certo che se hai solo una oggetto Banca2 in blocco puoi usare notify();, ma se ce ne sono di più per la programmazione concorrenziale dovresti usare notifyAll(); e verificare con un "while", chi deve o meno rientrare nello stato di blocco.

Spero di essere stato chiaro e di aver capito quello che ti serviva

ho visto adesso la tua risposta....
ho provato subito ma nn si blocca lo stesso!

[Donovant]

Non è possibile, chissà dove hai sbagliato...
Ristampa tutta la classe più la classe Runnable per come ti ho detto io, vediamo???

[Donovant]

A questo punto il problema mi sa che "saldo + s" non sia MAI minore di zero...altrimenti è impossibile che non si blocchi.

[fermat]

ti posto:

package contocorrente;

public class Banca2 {

    private int saldo;

    public Banca2(int saldo) {
        this.saldo = saldo;
    }

    synchronized public void operazione(int s) {
        if (saldo + s < 0) {
            System.out.println("Impossibile effettuare l'addebito " + s);
            try {
                wait();
            } catch (InterruptedException ie) {
            }
        } else {
            saldo += s;
            System.out.println("Modifica di " + s + " effettuata, Il tuo saldo è: " + saldo);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                System.out.println("Errore " + e.getMessage());
            }
        }
    }
}

class Modifica implements Runnable {

    Banca2 banca;
    int modifica;

    public Modifica(Banca2 banca, int modifica) {
        this.banca = banca;
        this.modifica = modifica;
        new Thread(this).start();
    }

    public void run() {
        banca.operazione(modifica);
    }
}

[Donovant]

Come ho scritto prima, è sicuramente (io non vedo altrimenti) il fatto che "saldo + s" non scenda mai sotto lo ZERO, e se questo non accade non vedo come java possa bloccare il "thread" (con quella condizione )

[fermat]

Originariamente inviato da Donovant
Come ho scritto prima, è sicuramente (io non vedo altrimenti) il fatto che "saldo + s" non scenda mai sotto lo ZERO, e se questo non accade non vedo come java possa bloccare il "thread" (con quella condizione )

io nn credo che il probleami sia solo quello.
prendo quest'altro esempio devo ho fatto due metodi separati, uno per aggiungere e l'altro per rimuovere:

package contocorrente;

class Banca {

    private int saldo;

    public Banca(int saldo) {
        this.saldo = saldo;
    }

    synchronized public void addebito(int s) {
        if (s > saldo) {
            System.out.println("Impossibile effettuare l'addebito " + s);
                        try {
                wait();
            } catch (InterruptedException ie) {
            }

        } else {
            saldo -= s;
            System.out.println("Addebito di " + s + " effettuato, Il tuo saldo è: " + saldo);
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                System.out.println("Errore: addebito non effettuato");
            }
        }
    }

    synchronized public void accredito(int s) {
        saldo += s;
        System.out.println("Accredito di " + s + " effettuato, Il tuo saldo è: " + saldo);
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            System.out.println("Errore: accredito non effettuato");
        }
    }
}

class Aggiungi implements Runnable {

    Banca banca;
    int aggiungi;

    public Aggiungi(Banca banca, int aggiungi) {
        this.banca = banca;
        this.aggiungi = aggiungi;
        new Thread(this).start();
    }

    public void run() {
        banca.accredito(aggiungi);
    }
}

class Rimuovi implements Runnable {

    Banca banca;
    int addebito;

    public Rimuovi(Banca banca, int addebito) {
        this.banca = banca;
        this.addebito = addebito;
        new Thread(this).start();
    }

    public void run() {
        banca.addebito(addebito);
    }
}

li richiamo così:

package contocorrente;

public class Main {

    public static void main(String[] args) {
        Banca banca = new Banca(0);
        new Rimuovi(banca, 300);
        new Aggiungi(banca, 600);
        new Aggiungi(banca, 500);
    }
}

teoricamente dovrebbe fermarsi dopo il Rimuovi, e invece fa tutte le operazioni e poi si blocca.

[Patrick Jane]

Tu fai partire 3 thread diversi!!

Così penso sia quello che che vuoi

class Banca implements Runnable {
  private Thread t;
  private boolean sospendi=false;
  private int saldo;
  private int[] array;
  
  Banca(int saldo) {
    t = new Thread(this);
    t.start();
    
    this.saldo = saldo;
  }
  
  void elementi(int array[]) {
    this.array = array;
  }
  
  synchronized private void gestisciSoldi(int n) {
    if(n > saldo) {
      try {
        System.out.println("Impossibile effettuare l'accredito!");
        sospendi = true;
        notify();
      } catch(Exception e) {}
    }
    
    else if(n > 0)  {
      saldo += n;
      System.out.println("Accredito di " + n + " effettuato, Il tuo saldo è: " + saldo);
    }
    else if(n < 0) {
      saldo += n; // Attenzione: In questo caso il numero è minore, quindi si ha una sottrazione
      System.out.println("Addebito di " + ~n + " effettuato, Il tuo saldo è: " + saldo);
    }
  }
  
  public void run() {
    try {
      for(int i=0; i<array.length; i++) {
        gestisciSoldi(array[i]);
        
        while(sospendi) {
          synchronized(this) {
            wait();
          }
        }
      }
    } catch(InterruptedException e) {}
  }
}

class TestBanca {
  public static void main(String args[]) {
    Banca b = new Banca(100);
    
    // Volendo puoi mettere un ciclo e passarne uno alla volta
    // creando comunque una struttura leggermente differente
    int[] array = {45,10,-20,500,10,10};
    b.elementi(array); // Passo l'array
  }
}

Output

Accredito di 45 effettuato, Il tuo saldo è: 145
Accredito di 10 effettuato, Il tuo saldo è: 155
Addebito di 19 effettuato, Il tuo saldo è: 135
Impossibile effettuare l'accredito!

Come noti alla fine si blocca!

Io passo l'array prima di iniziare e poi lo analizzo dal ciclo run()!
I valori nell'array in negativo verranno sottratti facendo l'addizione (in realtà il codice potrebbe essere messo un pochino meglio). E quelli positivi ovviamente sommati! ^^

[Donovant]

Non c'è bisogno di nessun array, a me il tuo codice funge normalmente, s>saldo e va in stallo