Lancement de classes Main

Version imprimable

05/09/2006, 17h17
zizou771

Lancement de classes Main

Slt à tous,

voici mon probleme:
j'ai 2 classes: Start et Stop contenant chacune une methode main.
Je lance la 1ere classe Start (qui tourne continuellement).
Je lance ensuite la classe Stop (censé arreter cette classe Start).
J'aimerai savoir s'il est possible à partir de ma classe Stop d'avoir acces a la classe Start.
En effet j'aimerai interrompre proprement la classes Start à l'aide de ma classe Stop.
Je pensais cela possible à l'aide de Thread mais ca apparement ca ne l'est pas.
Quelqu'un saurait t-il comment faire? ;)
Merci d'avance!!!!
05/09/2006, 17h41
in

je ne suis pas sûr, j'espère que je vais pas dire de betises ...

mais pour faire ce que tu veux, à mon avis, il te faut une troisième classe qui se charge de lancer tes classes Start et Stop dans deux threads séparés. Dans ce cas Stop pourra arrêter Start.

apres ça dépend aussi de quelle manière tu souhaite arrêter la classe Start ...
05/09/2006, 17h48
Scorpyosis

ou sinon communiqué par socket ta classe start se lance crée un petit serveur qui attends une connexion,connexion qui coresponds au message d'arret. Et de meme quand Stop veut arreter Start, elle se connecte au serveur de Stop et voilà le tour est joué. C'est simple et efficace, maintenant pourquoi as-tu besoin d'un prog Java pour en arreter un autre, c'est une autre histoire
05/09/2006, 18h01
zizou771

merci je vais regarger avec des sockets.

Start permet de lancer un scheduler qui fait des choses continuellement.
C'est a dire que je lance Start et peut etre que 15 jour apres il me faudra l'arreter.
Et je veut pouvoir arreter ce scheduler proprement (donc pas de kill, car il doit s'arreter quand il ne fait rien).
Alors j'ai penser faire une classe stop pour cela.
A moins que tu es une autre idee qui m'aurais echapper je suis preneur ;)
07/09/2006, 12h42
iohack

Une solution barbare qui évite de se prendre la tête avec les sockets ( surtout lorsque l'on en a jamais manipulés ) : passer par un fichier. Ta classe start scrute régulièrment la présence/contenu d'un fichier qui est créé/modifié par ta classe stop.
07/09/2006, 12h52
Scorpyosis

Citation:

Envoyé par iohack

Une solution barbare qui évite de se prendre la tête avec les sockets ( surtout lorsque l'on en a jamais manipulés ) : passer par un fichier. Ta classe start scrute régulièrment la présence/contenu d'un fichier qui est créé/modifié par ta classe stop.

C'est quand même super crade comme solution ! :mrgreen:
Si le programme plante, le fichier n'est pas détruit, alors l'autre programme pense que tout est ok vu qu'il y a toujours le fichier alors qu'en fait rien ne se passe. Les sockets sont certes plus long à mettre en oeuvre mais bon c'est pas la mère à boire non plus. Et puis des petits client serveurs en java ca se trouve facilement

Un socket cleint avec un sevreur ça se met en place en 1h ;) (tests compris).

Si tu veux j'ai même fais un exemple moi même :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package threads;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
 
public class Serveur extends Thread {
 
    private volatile boolean stop = false;
 
    private ServerSocket server = null;
 
    private Runner parent = null;
 
    public Serveur(Runner parent) {
        super("Serveur");
        this.parent = parent;
        try {
            server = new ServerSocket(3600);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
    @Override
    public void run() {
        BufferedInputStream buffer = null;
        Socket socket = null;
        char car;
        StringBuffer stringBuffer = new StringBuffer();
 
        try {
            socket = server.accept();
            buffer = new BufferedInputStream(socket.getInputStream());
 
            while (!stop) {
 
                while ((car = (char) buffer.read()) != '\n') {
                    stringBuffer.append(car);
                }
 
                System.out.println("Read : " + stringBuffer.toString());
 
                if (stringBuffer.toString().equals("stop")) {
                    stop = true;
                    parent.stopThread();
                    server.close();
                }
 
                stringBuffer = new StringBuffer();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (buffer != null)
                    buffer.close();
                if (socket != null)
                    socket.close();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
    public void stopIt() {
        stop = true;
    }
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package threads;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
 
 
public class Stop {
 
    private Socket socket = null;
 
    public Stop() {
        super();
        InetAddress adress = null;
        OutputStream out = null;
        try {
            adress = InetAddress.getByAddress(new byte[] {127,0,0,1});
            socket = new Socket(adress, 3600);
            out = socket.getOutputStream();
            out.write("stop\n".getBytes("UTF-8"));
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                if (out != null)
                    out.flush();
                if (socket != null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
    public static void  main(String args[]) {
        new Stop();
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package threads;
 
public class Runner extends Thread {
 
    private volatile boolean arret = false;
 
    private static Runner thread = null;
    Serveur serveur = null;
 
    public Runner() {
        super();
        setPriority(Thread.MIN_PRIORITY);
        serveur = new Serveur(this);
        serveur.start();
    }
 
    public void run() {
 
        while (!arret) {
            // traitement
            // Thread.yield();
        }
 
        System.out.println("Arrêt effectif du thread");
    }
 
    public static void main(String args[]) throws Exception {
        thread = new Runner();
        thread.exec();
    }
 
    public void stopThread() {
        this.arret = true;
    }
 
    private void exec() throws InterruptedException {
        this.start();
    }
}

07/09/2006, 13h12
Nicolas_75

Bonjour,

zizou771 :

Citation:

Start permet de lancer un scheduler qui fait des choses continuellement.
C'est a dire que je lance Start et peut etre que 15 jour apres il me faudra l'arreter.
Et je veut pouvoir arreter ce scheduler proprement (donc pas de kill, car il doit s'arreter quand il ne fait rien).
Alors j'ai penser faire une classe stop pour cela.
A moins que tu es une autre idee qui m'aurais echapper je suis preneur

Pourquoi ne retiens-tu pas l'idée d'un Timer lançant un TimerTask à intervalles réguliers, et interrompu par un .cancel(). Cette dernière méthode semble très propre :

Citation:

public void cancel()
Terminates this timer, discarding any currently scheduled tasks. Does not interfere with a currently executing task (if it exists).

Nicolas