[Thread] sincronia tra due processi

[Framek]

Ciao a tutti,
vorrei sottoporvi un mio problema per il quale ci sto scapocciando parecchio ... forse perchè sono un pò arruginito con i meccanismi che offre Java in casi come questi...
Ok, lo scenario che mi si presenta è questo:

vorrei implementare un sistema che, avviato, provvede a far eseguire un Thread e quindi delle operazione meglio definite nel run(), (per questo ho utilizzato un TimerTask in quanto è necessario che l'operazione si ripete ogni, p.es. 30sec.) e che, ad un certo punto, diciamo dopo un intervallo temporale X, il Thread di prima si interrompe e provvede a segnalare ad un secondo Thread che ora può eseguirsi.

Quindi, T1 parte, si ferma dopo un X di tempo, parte ora T2 che si eseguirà per un altro Y di tempo alla fine del quale, T1 dovrà ripartire e poi cilcicamente/automaticamente, dopo X parte T2 e cosi via...

Avevo pensato ad una classe con delle variabili statiche booleane da settare ogni qual volta a true/false e, quindi, il run() p.es. di T1 controlla in un while(true) lo stato della sua variabile, se true esegue, altrimenti blocca la sua esecuzione...

ma credo ci sia qualcosa che non va...

qualcuno ha una idea risolutiva?

Grazie

[zipangulu]

Bè una soluzione potrebbe essere quella che tu hai accennato di usare le variabili booleane , ma in tal modo l'altro thread "fermo" sta in "attesa attiva" non è ottima come cosa..
potresti magari tenere i riferimenti dei due thread in modo che ogni thread abbia il riferimento dell'altro e ognuno nel propio campo istruzioni sia in grado di dire "bene , è passato X tempo ora avvio l'altro thread e mi blocco"..

[Framek]

mmm... riusciresti a farmi un esempio con qualche rigo di codice?... cosa intendi per "tenere il riferimento del'altro thread"? Avevo pensato anche ad un terzo Thread che gestisse un po tutto... ma nada...

[zipangulu]

E' un codice MOLTO rozzo ma serve solo a rendere l'idea..e poi devo ancora mangiare e sono affamato pensa quanto possa essere bassa la qualità di questo codice (non controllo tutte le eventuali eccezioni):

import javax.swing.Timer;
import java.awt.event.*;
import javax.swing.JOptionPane;

class Esempio {

	private Thread [] t;
	private Runnable [] r;
	private Timer timer;
	private int tempo;

	public Esempio () {
		t = new Thread [2];
		r = new Runnable [2];
		timer = new Timer (1000 , new ActionListener () {
			public void actionPerformed (ActionEvent ae) {
				tempo++;
			}
		});
		r [0] = new Runnable () {
			public void run () {
				int durata = Integer.parseInt (JOptionPane.showInputDialog ("Quanti secondi devo restare in esecuzione (metti un numero intero!!)"));
				tempo = 0;
				int j = 0;
				System.out.println ("IO STAMPO ANDANDO A CAPO");
				while (tempo < durata) {
					System.out.println (j+"");
					j++;
					try {
						Thread.sleep (100);
					}catch (InterruptedException ie) {
						System.out.println ("IO THREAD 1 SONO STATO INTERROTTO MENTRE ATTENDEVO");
					}
				}
				System.out.println ("ora mi fermo e faccio partire l'altro thread");
				t [1] = new Thread (r [1]);
				t [1].start ();
			}
		};

		r [1] = new Runnable () {
			public void run () {
				int durata = Integer.parseInt (JOptionPane.showInputDialog ("Quanti secondi devo restare in esecuzione (metti un numero intero!!)"));
				tempo = 0;
				int j = 0;
				System.out.println ("IO NON VADO A CAPO");
				while (tempo < durata) {
					System.out.print (j+"");
					j++;
					try {
						Thread.sleep (100);
					}catch (InterruptedException ie) {
						System.out.println ("IO THREAD 2 SONO STATO INTERROTTO MENTRE ATTENDEVO");
					}
				}
				System.out.println ("ora mi fermo e faccio partire l'altro thread");
				t [0] = new Thread (r [0]);
				t [0].start ();
			}
		};
		t [0] = new Thread (r [0]);		
		timer.start ();
		t [0].start ();
	}

	public static void main (String [] args) {
		new Esempio ();
	}

}

oppure potresti fare un'altra cosa del tipo:
avvii un thread t1
nel run di t1:
while (veraCondizione) {
svolgi ciò che deve svolgere il thread
"crea" e avvia t2
t2.join ()
}

[Framek]

ciao e grazie mille per la risposta... a stomaco vuoto vale di più ... scherzi aparte, la tua soluzione inizia a prendere forma... tuttavia, quando dici:

System.out.println ("ora mi fermo e faccio partire l'altro thread");

in che modo stai mettendo in attesa il thread?

e poi, ho visto che l'oggetto timer lo utilizzi solo una volta ed alla fine del'esecuzione di T2 prima di rilanciare T1... cosa fa questo?

E poi, ultima cosa... utilizzando TimerTask, posso dire per esempio al'oggetto time, schedule(task1, 1000, 10000) , ovvero eseguiil task1 dopo l'attesa di 1 sec. e poi ripetilo ogni 10 sec. ... qui potrei farlo?

[c0der]

Ti posto la mia soluzione, con un codice facilmente customizzabile.
- thread T1 con frequenza 1 secondo ed esecuzione totale 3 secondi
- thread T2 con frequenza 1 secondo ed esecuzione totale 4 secondi

import java.util.concurrent.*;
import static java.util.concurrent.TimeUnit.*;

class T1 implements Runnable {
    public void run() {
        System.out.println("T1");
    }
}

class T2 implements Runnable {
    public void run() {
        System.out.println("T2");
    }
}

class Demo {
    private ScheduledExecutorService scheduler =
       Executors.newScheduledThreadPool(1);
    private ScheduledFuture<?> t1Handle, t2Handle;

    public Demo() {
        StopT2StartT1();
    }
         
    private void StopT2StartT1() {
        if (t2Handle != null)
            t2Handle.cancel(true);    
        // T1: frequenza 1 secondo
        t1Handle = scheduler.scheduleAtFixedRate(new T1(), 0, 1, SECONDS);
        // 3 secondi di esecuzione totale
        scheduler.schedule(new Runnable() {
            public void run() {
                StopT1StartT2();
            }
        }, 3, SECONDS);  
    }
    
    private void StopT1StartT2() {
        t1Handle.cancel(true);
        // T2: frequenza 1 secondo
        t2Handle = scheduler.scheduleAtFixedRate(new T2(), 0, 1, SECONDS);
        // 4 secondi di esecuzione totale
        scheduler.schedule(new Runnable() {
            public void run() {
                StopT2StartT1();
            }
        }, 4, SECONDS);        
    }
         
    public static void main(String args[]) {
        new Demo();
    }
 }

[zipangulu]

System.out.println ("ora mi fermo e faccio partire l'altro thread");

in che modo stai mettendo in attesa il thread?

bè in realtà non è che lo metto in attesa , lui termina le sue istruzioni quindi termina il suo "ciclo di vita"..poi al termine dell'altro lo "ricreo" e riavvio

e poi, ho visto che l'oggetto timer lo utilizzi solo una volta ed alla fine del'esecuzione di T2 prima di rilanciare T1... cosa fa questo?

mmm no , io il timer lo istanzio e inizializzo specificandogli cosa deve fare ad ogni suo evento (ogni secondo incrementa una variabile)..
istanziando ed inizializzando un thread (t [0]) ancora non lo sto mandando in "esecuzione" , gli ho solo dato le direttive , fin quando non gli invoco lo "start" lui nn parte , quindi prima di avviarlo avvio il timer (una sola volta) perchè è condiviso (condiviso per modo di dire , in quanto i due thread non vivono contemporaneamente) dai thread..

[Framek]

Ciao c=der... grazie anche a te per avermi risposto...effettivamente quello che dici è proprio vero... ma se, mettiamo caso, io vorrei un T1 che si esegue ogni 60sec., posi si stoppa perchè dopo 360sec, deve esere eseguito T2, poi però al termine dell'esecuzione di T2, deve rpartire T1... dici che anche questo si possa fare?

Grazie...

PS: mi devo assentare un po

[c0der]

Il codice che ti ho scritto funziona già come chiedi:
1) T1 si esegue con frequenza 1 secondo per una esecuzione totale di 3 secondi
dopo di che parte:
2) T2 che si esegue con frequenza 1 secondo per una esecuzione totale di 4 secondi
dopo di che riparte tutto da (1) a ciclo infinito.

Per i tempi basta che modifichi i parametri in StopT2StartT1 e StopT1StartT2 a tuo piacimento.

[Framek]

okok...grazie per le dritte... domani provo il codice adattandolo al mio progetto e vi faccio sapere...