Discussion :

[mcherkao88]

<code>Bonjour,
Je vient de faire un programme de chat entre PC et SERVEUR sous Python.J'ai réalisé l'a-synchronisme via les Threads.
Mon problème est que je ne peut visualisée les donnée envoyées par le client au serveur qu'après faire une émission du serveur au client. Et si j'élimine par exemple le thread d'émission du serveur, alors là l'affichage du message reçu par le serveur est immédiat. Si quelqu'un pourrait me donner un coup de main, je lui serai reconnaissant.
Voilà ci joint mon programme:

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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#####################CLIENT#####################
 
host = "00:24:7E:D6:C5:9A"
port = 3
 
import socket, sys, threading, time
from bluetooth import *
 
class ThreadReception(threading.Thread):
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion = conn           
 
    def run(self):
        while 1:
            message_recu = self.connexion.recv(1024)
            print "*" + message_recu + "*"
            if message_recu.upper() == "FIN":
                break
            time.sleep(0.001)
 
class ThreadEmission(threading.Thread):
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion = conn          
 
    def run(self):
        while 1:
            message_emis = raw_input()
            self.connexion.send(message_emis)
            time.sleep(0.001)
 
# Programme principal - Établissement de la connexion :
connexion = BluetoothSocket( RFCOMM )
try:
    connexion.connect((host, port))
except socket.error:
    print "La connexion a échoué."
    sys.exit()    
print "Connexion établie avec le serveur."
 
# Dialogue avec le serveur : on lance deux threads pour gérer
# indépendamment l'émission et la réception des messages :
th_E = ThreadEmission(connexion)
th_R = ThreadReception(connexion)
th_E.start()
th_R.start()
th_E.join()
th_R.join()
connexion.close()
###############SERVEUR####################
 
from bluetooth import *
import socket, sys, threading,time
 
port = 3
 
class ThreadReception(threading.Thread):
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion = conn           
 
    def run(self):
        while 1:
            try:
                message_recu = self.connexion.recv(1024)
                print "*" + message_recu + "*"
                if message_recu.upper() == "FIN":
                    break
            except:pass    
            time.sleep(0.001)
 
 
class ThreadEmission(threading.Thread):
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion = conn          
 
    def run(self):
        while 1:
            message_emis = raw_input()
            try:
                self.connexion.send(message_emis)
                if message_emis.upper() == "FIN":
                    break
            except:pass    
            time.sleep(0.001)
 
# Programme principal - Établissement de la connexion :
 
server_sock = BluetoothSocket( RFCOMM )
server_sock . bind(( "", 3))
server_sock . listen(2)
 
connexion , client_info = server_sock . accept( )
print "Accepted connection from " , client_info
 
# Dialogue avec le client : on lance deux threads pour gérer
# indépendamment l'émission et la réception des messages :
 
th_R = ThreadReception(connexion)
th_E = ThreadEmission(connexion)
th_E.start()
th_R.start()
th_R.join()
th_E.join()
 
connexion.close()
server_sock.close()
<code></code></code>

[wiztricks]

De loin, ce qui me paraît "bloquant" est raw_input i.e. tant que la saisie n'est pas terminée çà devrait attendre.

Si ma théorie est sensée, elle devrait être testable.
Au lieu de supprimer la threads "completement", passez "au-dessus" de raw_input en mettant une chaîne de caractères constante dans message_emis:

Code Python :

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

1
2
3
4
5
        while 1:
#            message_emis = raw_input()
            message_emis = 'foo'
            self.connexion.send(message_emis)
            time.sleep(0.001)

Pour le reste, à moins que le but de l'exercice ne soit d'apprendre à jouer avec les threads et TCP/IP, je ne peux que vous recommander de regarder ce que sait faire Twisted

-W

[mcherkao88]

Je vois que de la sorte, j'enverrai toujours le même message.Or moi,j'ai besoin d'émettre et recevoir des messages de la même façon qu'en MSN .
Est-il impossible?

[wiztricks]

Je vois que de la sorte, j'enverrai toujours le même message.Or moi,j'ai besoin d'émettre et recevoir des messages de la même façon qu'en MSN .
Est-il impossible?

Je ne vous ai proposé cela que pour vous permettre de faire un diagnostic: est-ce le raw_input qui est bloquant ou est-ce autre chose...

Si c'est raw_input, votre design est flagalla à cause du Global InterLock (GIL).

GIL est un sacré personnage. Il demande du temps à être apprivoisé.
Si vous ne vous y êtes pas déjà frotté, Twisted est ce qu'il vous faut.

Si vous voulez vous frottez à GIL, vous ne pourrez qu'apprendre à le respecter (et à fuir quand vous le voyez).

Idée.

• Mettre la saisie dans un process et non dans un thread.
• Etablir une FIFO (Queue) entre le process qui fait les saisies et celui qui 'envoie' les messages aux clients.

Vous avez dans ce cas un process qui s'occupe de la connexion TCP et un autre qui s'occupe des entrées sortie clavier et entre les deux de la mémoire partagée et des sémaphores qui vont vous permettre de...

Note: la bibliothèque processing rend tout cela assez transparent de sorte que vous pouvez faire cela comme s'il s'agissait de threads.

Cela fait, l'étape suivante sera d'avoir un serveur qui gère plein de connexions entre différents clients et distribue les messages reçus des uns aux autres.

Si vous voulez faire cela proprement, il vous faut réaliser un truc similaire au [ame="http://en.wikipedia.org/wiki/Reactor_pattern"]pattern reactor[/ame].
que vous donne Twisted...

-W