Discussion :

[kobain4]

Bonjour,

Je souhaite réaliser un réseau simple entre deux utilisateurs. J'utilise un thread pour la connexion avec le client et un autre qui affiche la durée de connexion. Le problème est le suivant : lorsque la connexion entre le serveur et le client est établie, je ne peux pas utiliser un bouton sur le GUI pour faire une autre action, comme si le thread l'en empêchait.

Voici mon code côté 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
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
# -*- coding: cp1252 -*-
# python version 2.7.8
 
import socket,sys,ctypes,pygame,time
from Tkinter import *
from threading import Thread
 
#DIMENSIONS DE L'ECRAN
 
SM_CXSCREEN = 0
SM_CYSCREEN = 1
largeurScreen = ctypes.windll.user32.GetSystemMetrics(SM_CXSCREEN)
hauteurScreen = ctypes.windll.user32.GetSystemMetrics(SM_CYSCREEN)
largeurMain=240
hauteurMain=hauteurScreen
 
#SERVEUR
 
HOST = '192.168.0.12'
PORT = 6027
 
mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
try:
     mySocket.bind((HOST, PORT))
except socket.error:
     print "La liaison du socket à l'adresse choisie a échoué."
     sys.exit()
 
 
#VARIABLES GLOBALES
 
#CLASSES
 
#thread serveur
 
class Serveur(Thread):
    """Thread chargé de se connecter au client"""
 
    def __init__(self):
        Thread.__init__(self)
 
    def run(self):
          while 1:
               #Attente de la requête de connexion d'un client :
               print "Serveur prêt, en attente de la connexion du client..."
               mySocket.listen(5)
 
               #Etablissement de la connexion :
               connexion, adresse = mySocket.accept()
               print "Client connecté, adresse IP %s, port %s" % (adresse[0], adresse[1])
               texte.set("Client connecté")
               thread_time.start()
 
               #Dialogue avec le client :
               connexion.send("Vous êtes connecté au serveur")
               msgServeur=raw_input("fin?")
               if msgServeur.upper()=="FIN" or msgServeur.upper()=="":
                    thread_time.stopthread()
                    texte.set("Client déconnecté")
                    break
          connexion.close()
          sys.exit()
 
#thread durée
 
class Duree(Thread):
    """Thread chargé d'afficher le temps écoulé"""
 
    def __init__(self):
        Thread.__init__(self)
        self.arret=False
 
    def run(self):
          try:
             while 1:
               raw_time=time.clock()
               s=int(raw_time)
               h=0
               m=0
               if s >= 60:
                 m = s//60
                 s -= m*60
               if m >= 60:
                   h = m//60
                   m -= h*60
               temps.set(str(h)+' h '+str(m)+' m '+str(s)+' s')
               if self.arret==True:
                    raise
          except:
               print "Arrêt du thread Durée Serveur"
 
    def stopthread(self):
        self.arret=True        
 
 
#DEFINITIONS
 
def quitter():
     print "quitter"
 
#PROGRAMME PRINCIPAL
 
Mafenetre=Tk()
Mafenetre.title("Collaborative Tool")
texte=StringVar()
temps=StringVar()
#Mafenetre.configure(bg="white")
Mafenetre.geometry('%dx%d+%d+%d' % (largeurMain,hauteurMain,largeurScreen-253,0))
 
thread_serveur=Serveur()
thread_time=Duree()
thread_serveur.start()
 
LabelTime=Label(Mafenetre,textvariable=temps)
LabelTime.pack()
 
LabelServeur=Label(Mafenetre,textvariable=texte)
LabelServeur.pack()
 
BoutonQuitter = Button(Mafenetre, text ='Quitter', command = quitter)
BoutonQuitter.pack(side = LEFT, padx = 5, pady = 5)
 
Mafenetre.mainloop()

Merci pour votre aide,

[wiztricks]

Salut,

Pas facile de vous aider si vous postez un programme qu'on ne peut pas lancer pour "voir" ce que vous constatez.
On peut bien sûr lire votre code... Et quand on trouve une construction du style:

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
    def run(self):
          try:
             while 1:
               raw_time=time.clock()
               s=int(raw_time)
               h=0
               m=0
               if s >= 60:
                 m = s//60
                 s -= m*60
               if m >= 60:
                   h = m//60
                   m -= h*60
               temps.set(str(h)+' h '+str(m)+' m '+str(s)+' s')
               if self.arret==True:
                    raise
          except:
               print "Arrêt du thread Durée Serveur"

on se dit que quelque part avec un code aussi pourri, vous cherchez les problèmes.

Puis, on peut essayez de construire un machin aussi bancale pour voir comment çà vole.
Au départ, çà donne un truc comme:

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
import Tkinter as tk
import threading
 
def endless_loop(variable):
    c = 0
    while 1:
        variable.set(c)
        c += 1
 
def quitter():
    print ('quitter')
 
root = tk.Tk()
tk.Button(text='Quit', command=quitter).pack()
variable = tk.IntVar()
tk.Label(textvariable=variable).pack()
 
p =threading.Thread(target=endless_loop, args=(variable,))
p.daemon=True
p.start()
 
tk.mainloop()

snif, çà "fonctionne".
Ajoutons le bout de thread qui lance le endless_loop:

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
import Tkinter as tk
import threading
 
def foo():
    p =threading.Thread(target=endless_loop, args=(variable,))
    p.daemon=True
    p.start()
    z = input()
 
def endless_loop(variable):
    c = 0
    while 1:
        variable.set(c)
        c += 1
 
def quitter():
    print ('quitter')
 
root = tk.Tk()
tk.Button(text='Quit', command=quitter).pack()
variable = tk.IntVar()
tk.Label(textvariable=variable).pack()
 
p =threading.Thread(target=foo)
p.daemon=True
p.start()
 
tk.mainloop()

Et voili, çà bugge.

Dans le cas général, si un thread compute bound on s'attend à ce que l'ordonnanceur fasse quand même avancer les autres threads. Python2 s'en sort assez mal dans ce cas, et il y a des corrections dans Python 3.2+ qui permettent d'être un peu plus "correct".
note: ce code fonctionne pas trop mal sur Python3.4

Ceci dit dans votre cas, mettre à jour l'heure avec une précision de la seconde ne mérite pas de boucler à la vitesse du CPU, un time.sleep(0.3) dans le corps de la boucle est suffisant pour "donner l'heure" sans pour autant fusiller un CPU et mettre tout le programme par terre.

- W