Ecriture / lecture dans un tableau

Bonjour,

Je vous explique mon soucis:
Je fait un programme qui communique via liaison RS232.

Niveau threading :
Un fonction dépile des trames que j'ai stocké au préalable dans un tableau 'rs_transmit'. 0.5s.
Une autre fonction scrute la liaison et me stocke toute les trames reçu dans un tableau : rs_read. 0.5s.

Dans mon programme principal je lance différence séquence. Lorsque je lance une action (ajoute une ligne a rs_transmit) je vais recevoir un acquittent si il est ok je continue, sinon je voit [...].

Ma question, est ce que ca pose problème que je scrute un tableau(rs_read) (fonction principale) et que je le remplisse (rs_read), sans prévoir aucune structures de lock/unlock ? Car j'ai l'impression que je ne peut pas manipuler le tableau en même temps

Y a pas de tableaux en Python.

Quelle est la structure de données que tu désignes du terme impropre de “tableau“ stp ?

Citation:

---

Envoyé par eyquem

Y a pas de tableaux en Python.

Quelle est la structure de données que tu désignes du terme impropre de “tableau“ stp ?

---

Désolé, abus de language de ma part : list

acceder simultanement a la table ça peut-être mal ... surtout avec 3 threads.
un verrou ça coute rien et c'est plus sûr.

Citation:

---

Envoyé par josmiley

acceder simultanement a la table ça peut-être mal ... surtout avec 3 threads.
un verrou ça coute rien et c'est plus sûr.

---

Comment doit je faire pour mettre un verrou ?
Un verrou peut être mis sur une variable ?

le verrou entoure la zone memoire qui doit etre accedée.

verrou=thread.allocate_lock()

def lafonctionquitraitelatable(action):
verrou.acquire()
...si action == lire
...si action == ecrire
...si action == ajouter
verrou.release()

je ne sais pas si on peut poser un verrou autour d'une variable.
cette exemple ne corespond peut-etre pas a ce que tu veux faire.

Bonjour,

C'est assez facile d'utiliser un verrou avec le module threading.

Pour initialiser un verrou:

Code:

---

verrou = threading.Lock()

---

Pour qu'un thread demande le verrou (en attendant qu'il soit libre):

Code:

---

verrou.acquire()

---

Et après le travail, pour le relacher (=pour permettre aux autres threads d'y accéder):

Code:

---

verrou.release()

---

En fait, il n'y a pas d'autres liaisons entre le verrou et l'accès aux ressources que celle que donne le code du programmeur.

Tu peux t'inspirer de mon tuto ici: http://python.jpvweb.com/mesrecettespython/thread_lock.

Tyrtamos

Bonsoir,

Citation:

---

Envoyé par josmiley

je ne sais pas si on peut poser un verrou autour d'une variable.
cette exemple ne corespond peut-etre pas a ce que tu veux faire.

---

Il faut penser à un verrou comme un moyen de sérialiser les opérations à l'intérieur de acquire/release.
A priori, ils ne sont nécessaire que pour rendre "atomique" une séquence de type lecture/modification/écriture de variables globales.

Plutôt que de mettre une gestion de verrous autour des opérations de mise à jour d'une liste, pourquoi ne pas utiliser l'objet Queue du module threading? Les opérations put et get sont déjà protégées par un verrou.
Par contre, dans sa description l'auteur ne précise pas si ses listes sont utilisées pour faire un accès direct (le nième élément) ou seulement le premier et de dernier. Dans ce cas, queue ne va pas le faire.
-W

J'ai essayé d'implémenter mes balise verrou.acquire() et verrou.realease() autour de tous mes commandes .append() et .pop() de mes deux listes. Mais J'ai l'impression que je tombe toujours dans une boucle ou mes thread ne s'execute plus.


-> thread1 : transmit
while(1):
si taille(rs_transmit) != 0 : // regarder si il y a une trame a envoyer
pour i suivant la taille de rs_transmit: // envoi de toutes les trames
verrou.acquire()
frame = rs_transmit.pop(0)
verrou.release()
com.write(frame) // envoi RS

-> thread2 : reception
while(1):
a = com.read(200) // lecture du buffer RS
si a != "" :
verrou.acquire()
rs_reception.append(a)
verrou.release()

-> IHM : lancement d'action via des sequences ou des scripts
verrou.acquire()
rs_transmit.append(cmd)
verrou.realease()


voila en gros ce que je fait.

non s'pas ça.

c'est plutot du genre:

->def traitementt(action,arg)
verrou.acquire()
si action==transmit : frame = rs_transmit.pop(0)
si action==reception : rs_reception.append(arg)
si action==commande : rs_transmit.append(arg)
verrou.realease()

-> thread1 : transmit
while(1):
si taille(rs_transmit) != 0 : // regarder si il y a une trame a envoyer
pour i suivant la taille de rs_transmit: // envoi de toutes les trames
traitement(transmit,None)
com.write(frame) // envoi RS

-> thread2 : reception
while(1):
a = com.read(200) // lecture du buffer RS
si a != "" :
traitement(reception,a)

-> IHM : lancement d'action via des sequences ou des scripts
traitement(commande,cmd)

tu crees une fonction qui traite la liste et c'est cette fontion que tu dois verouiller; les threads feront des appels et attendront que la fonction se libère.

Citation:

---

Envoyé par josmiley

non s'pas ça.
tu crees une fonction qui traite la liste et c'est cette fontion que tu dois verouiller; les threads feront des appels et attendront que la fonction se libère.

---

C'est pas mal du tout, ca a l'air d'être nettement mieux. je poursuit mes essais pour confirmer ses premiers tests.

les gars, vous devriez essayer de mettre vos codes entre deux balises [code]-votre code ici-[/code]

C'est plus clair, et conserve l'identation ;)

l'exemple donné précédemment donne ceci :

Code:

---

-votre code ici-

---

largement mieux, non ?