Discussion :

[Hind4Dev]

Un peu confondu pour commencer en en utilisant ExecutorService, j'ai une application clients/serveur, où chaque client doit exécuter quelques méthodes par ordre, ainsi que le serveur tout en se partageant quelques données, j'ai eu des problèmes en implémentant de simples threads donc j'ai pensé à refaire avec ExecutorService, mais j'ai senti un conflit en suivant les tutoriels :

• Est ce que cette ExecutorService prend en charge mes threads clients ou leurs tâches, est ce que ce code est bon

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
public class ClientThread implements Runnable{
        private int id;                   private Socket socket;
 
        public ClientThread(int id, Socket s){
             this.id = id;
             this.socket = s;
        }
        public void run(){
               méthodeTache1();
               méthodeTache2();
               ...
        }
        méthodeTache1(){}
        méthodeTache2(){}
}
 
public class Server{
       public void runServer(){
              Runnable serverTask = () -> {                
                    ServerSocket srv = new ServerSocket(Integer.valueOf(txtPort.getText()));
                    ExecutorService execClients = Executors.newFixedThreadPool(nbrClients);
                    for(int i = 0 ; i < nbrClients ; i++){
                        execClients.submit(new ClientThread(i, srv.accepte()));
                    }
              }
             Thread serverThread = new Thread(serverTask);
            serverThread.start();
       }
}

• Est ce que l'ExecutorService s'en charge de démarrer les thread clients sans que je mette start() ?

svp besoin d'un cours pour débutants dans ce domaine

merci

[tchize_]

un executorService reçois des Runnalbe ou des Callable, pas des Thread. Il a normalement ses propre thread. Après, pour ce qui est de l'exécution des méthodes, ca dépend de l'implémentation que tu prend de l'executorService. En général c'est le ThreadPoolExecutor qu'on utilise, qui a une certain nombre de thread et dispatche les tâches dans ceux-ci avec une pile d'attente.

Donc oui, tu peux utiliser ça pour limiter le nombre de threads dont ton programme à besoin.

Mais dans ton code là ça sert à rien. Tu crée N thread pour N client dans le service, ça n'apporte rien par rapport à utiliser directement tes threads

[Hind4Dev]

voudriez vous bien m'expliquer donc ça sert à faire quoi au juste, pour que je puisse bien l'exploiter, car le problème que j'ai dans ma présente implémentation, est l'attente de certains paramètres par messages avant de lancer l'exécution d'autres méthodes, je n'ai pas pu trouver des listeners pour les sockets

[professeur shadoko]

car le problème que j'ai dans ma présente implémentation, est l'attente de certains paramètres par messages avant de lancer l'exécution d'autres méthodes, je n'ai pas pu trouver des listeners pour les sockets

java.nio.channels.SocketChannel et son Selector?

[Hind4Dev]

non sans channel ni selector, déjà je les connais même pas, je suis débutante en programmation réseau, j'ai juste mon ServerSocket et les Scokets pour chaque client

[professeur shadoko]

non sans channel ni selector, déjà je les connais même pas, je suis débutante en programmation réseau, j'ai juste mon ServerSocket et les Scokets pour chaque client

et bien voilà l'occasion d'apprendre
les sélecteurs ça se trouve dans plein de langages de programmation et c'est bien pratique pour te réveiller ...

[Gugelhupf]

Salut,

Tu peux utiliser les Selector si tu souhaites gérer plusieurs channel via un thread, mais tu n'es pas obligée.

Est ce que l'ExecutorService s'en charge de démarrer les thread clients sans que je mette start() ?

Si tu utilises un ExecutorService alors pas de start(), mais tu mélanges un peu les threads (qui nécessitent l'utilisation du start()) et les pools de threads dans ton code.


A+

[Hind4Dev]

Merci pour toutes vos suggestion. Effectivement, j'ai commencé en Java NIO, mais je trouve du mal à comprendre le fonctionnement quand il s'agit d'accepter plusieurs clients. Donc, voici l'architecture de mon réseau

j'ai mis en place le code du serveur et j'arrive à connecter autant de clients que je voudrai, seulement j'ai un petit soucis, le client A est un client lancé directement sur un port depuis le serveur, car je n'en ai qu'un, c'est juste pour pouvoir effectuer quelques calculs que je ne veux pas faire directement sur le serveur, mais les clients B il en existe autant que possible, qui se connectent depuis un autre port différent de celui de A. Quand j'ai implémenté la boucle de connexion sur le serveur, à chaque fois que je connecte un B, un A se crée automatiquement, je ne sais comment représenter cette architecture.

Code Serveur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
73
 
public class Server {
 
private int portDealer;
private int portParticipants;
 
private ServerSocketChannel createServerChannel(Selector selector, int port) {
        try {
            //création d'un canal serveur
            ServerSocketChannel ssc = ServerSocketChannel.open();
 
 
            //le configurer en mode non bloquant
            ssc.configureBlocking(false);
 
 
            //configuration de la socket sous jacente
            ServerSocket ss = ssc.socket();
            ss.bind(new InetSocketAddress(port));
 
 
            //configuration du selector
            ssc.register(selector, ssc.validOps());
 
 
            return ssc;
 
 
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
        return null;
    }
 
   public void startServer(Dealer dealerThread){
        try {
            Selector select = Selector.open();
 
 
            //création des cannaux non bloquant pour Dealer/Participant
            ServerSocketChannel sscDealer = createServerChannel(select, portDealer);
            ServerSocketChannel sscParticipants = createServerChannel(select, portParticipants);
 
 
            while (true) {
                System.out.println("Attente ...");
                select.select();
 
 
                Iterator<SelectionKey> it = select.selectedKeys().iterator();
                while (it.hasNext()) {
                    SelectionKey key = it.next();
                    if (key.isAcceptable()) {
                        ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
 
 
                        Socket socket = ssc.socket().accept();
 
 
                        dealerThread.setDealerSocket(socket);
                        Thread dealer = new Thread(dealerThread);
                        dealer.start();
                    }
                    it.remove();
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
 
}

Classe Dealer qui est le client A

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public class Dealer implements Runnable{
 
private int port;
private Socket dealerSocket;
 
 
    @Override
    public void run() {
        System.out.println("Dealer connecté ..");
    }
    public Dealer(int port) {
        this.port = port;
    }
}

Classe Client qui est n'importe quel client B

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
public class Client {
 
private int port;
private String adresse;
private Socket socket;
 
public void connect(){
        try{
            socket = new Socket(adresse, port);
            System.out.println("Connexion établie..");
 
        }catch(IOException e){
            e.printStackTrace();
            System.exit(1);
        }
    }
 
}

J'ai besoin d'un seul Dealer via la socket sscDealer et n participants vis sscParticipants , le A doit communiquer avec tous les B, les B ne se communiquent pas
Merci