Debian possède ENFIN un noyau entièrement libre...

Michel Talon a écrit :

Si maintenant il s'agit de synchroniser plusieurs processus, il n'y a
pas de construction de sémaphore possible par des méthodes similair es,
sauf à recourir à des appels systèmes spécifiques (sémaphores system V
ou posix) ou des bidouilles via le système de fichiers (créer des
fichiers verrouillés avec fcntl).

non

def ecriture(self):
self.mutex.lock()
while (self.lecture!=0):
time.sleep(0.1)

tu prends un ticket dans la file d'attente, quand tu la , tu attends que
les autre est fini




remy
--
http://remyaumeunier.chez-alice.fr/

On 1/10/11 9:03 PM, remy wrote:

def ecriture(self):
self.mutex.lock()
while (self.lecture!=0):
time.sleep(0.1)

C'est vraiment moche le Python. C'est vraiment moche le multi-thread.

Je prefere du Perl et du multi-process.


--
Recherche un admin Linux/Perl devel pour un poste
plutot intéressant basé sur Singapore. Me contacter
directement pour plus d'information.

Le Mon, 10 Jan 2011 14:03:36 +0100,
remy <remy@fctpas.fr> écrivait :

Michel Talon a écrit :

Si maintenant il s'agit de synchroniser plusieurs processus, il n'y a
pas de construction de sémaphore possible par des méthodes similaires,
sauf à recourir à des appels systèmes spécifiques (sémaphores system V
ou posix) ou des bidouilles via le système de fichiers (créer des
fichiers verrouillés avec fcntl).

non

def ecriture(self):
self.mutex.lock()
while (self.lecture!=0):
time.sleep(0.1)

tu prends un ticket dans la file d'attente, quand tu la , tu attends que
les autre est fini

Et comment positionnes-tu self.lecture ?

Fais gaffe, terrain glissant ;-)

JKB

--
Si votre demande me parvient sur carte perforée, je titiouaillerai très
volontiers une réponse...
=> http://grincheux.de-charybde-en-scylla.fr

JKB a écrit :

Le Mon, 10 Jan 2011 14:03:36 +0100,
remy <remy@fctpas.fr> écrivait :

Michel Talon a écrit :

Si maintenant il s'agit de synchroniser plusieurs processus, il n'y a
pas de construction de sémaphore possible par des méthodes similaires,
sauf à recourir à des appels systèmes spécifiques (sémaphores system V
ou posix) ou des bidouilles via le système de fichiers (cré er des
fichiers verrouillés avec fcntl).

non

def ecriture(self):
self.mutex.lock()
while (self.lecture!=0):
time.sleep(0.1)

tu prends un ticket dans la file d'attente, quand tu la , tu attends q ue
les autre est fini

Et comment positionnes-tu self.lecture ?

Fais gaffe, terrain glissant ;-)

JKB

c'est le nombres de lecture en cour puisque tu peux faire plusieurs
lecture a la fois contrairement aux écriture


--
http://remyaumeunier.chez-alice.fr/

tu prends un ticket dans la file d'attente, quand tu la , tu attends q ue
les autre est fini

Et comment positionnes-tu self.lecture ?

Fais gaffe, terrain glissant ;-)

bien vu j'ai un bug la decrementation de la lecture n'est pas protég er

import threading
import time
import random
from PyQt4 import QtGui,QtCore


class TasMemoire (QtCore.QThread):

def init(self):
global a
self.a=0
self.lecture=0
QtCore.QThread.__init__(self,None)
self.mutex=QtCore.QMutex()
self.mutex2=QtCore.QMutex()

def getMemoire(self):
return self.a
def setMemoire(self,val):
self.a=val
def debutLecture(self):
self.mutex.lock()
self.lecture=self.lecture+1
self.mutex.unlock()

def finLecture(self):
self.mutex2.lock()
self.lecture=self.lecture-1
self.mutex2.unlock()

def ecriture(self):
self.mutex.lock()
while (self.lecture!=0):
time.sleep(0.1)
def finecriture(self):
self.mutex.unlock()


class add (threading.Thread):
def __init__ (self,mem):
global tas
tas=mem
threading.Thread.__init__ (self, target=self.run)




def run (self):
while True:
r = random.randint(1,5)
time.sleep(r)
tas.ecriture()
var=tas.getMemoire()
var=var+1
tas.setMemoire(var)
tas.finecriture()
tas.debutLecture()
print 'ecriture plus val= %d'%tas.getMemoire()
tas.finLecture()

class sup (threading.Thread):
def __init__ (self,mem):
global tas
tas=mem
threading.Thread.__init__ (self, target=self.run)




def run (self):
while True:
tas.ecriture()
var=tas.getMemoire()
var=var-1
tas.setMemoire(var)
tas.finecriture()
tas.debutLecture()
print 'ecriture moins val= %d'%tas.getMemoire()
tas.finLecture()
r = random.randint(1,5)
time.sleep(r)



class Lecture (threading.Thread):
def __init__ (self,mem):
global tas
tas=mem
threading.Thread.__init__ (self, target=self.run)




def run (self):
while True:

tas.debutLecture()
print 'lecture val= %d'%tas.getMemoire()
tas.finLecture()
r = random.randint(1,5)
time.sleep(r)





memoire = TasMemoire ()
memoire.init()
Thread1 = add (memoire)
Thread1.start()
Thread2 = add (memoire)
Thread2.start()
Thread3 = sup (memoire)
Thread3.start()
Thread4 = sup (memoire)
Thread4.start()

a = Lecture (memoire)
a.start()
b = Lecture (memoire)
b.start()
c = Lecture (memoire)
c.start()
d = Lecture (memoire)
d.start()
e = Lecture (memoire)
e.start()
f = Lecture (memoire)
f.start()
g = Lecture (memoire)
g.start()
h = Lecture (memoire)
h.start()



je vous laisse le soin de chargé la mule :-)


--
http://remyaumeunier.chez-alice.fr/

remy <remy@fctpas.fr> wrote:

non

def ecriture(self):
self.mutex.lock()
while (self.lecture!=0):
time.sleep(0.1)

tu prends un ticket dans la file d'attente, quand tu la , tu attends que
les autre est fini

Et comment deux processus différents peuvent ils avoir connaissance
de leurs mutex respectifs? A moins de regarder un événement externe
commun, comme un fichier, et pour avoir un minimum d'atomicité, en
posant un verrou sur le fichier?

S'il existe des sémaphores system V nommés, c'est justement pour que des
processus différents puissent y accéder, par leur nom. Le problème est
qu'ils survivent à la mort accidentelle de ces processus.

--

Michel TALON

Le Mon, 10 Jan 2011 14:57:42 +0100,
remy <remy@fctpas.fr> écrivait :

JKB a écrit :

Le Mon, 10 Jan 2011 14:03:36 +0100,
remy <remy@fctpas.fr> écrivait :

Michel Talon a écrit :

Si maintenant il s'agit de synchroniser plusieurs processus, il n'y a
pas de construction de sémaphore possible par des méthodes similaires,
sauf à recourir à des appels systèmes spécifiques (sémaphores system V
ou posix) ou des bidouilles via le système de fichiers (créer des
fichiers verrouillés avec fcntl).

non

def ecriture(self):
self.mutex.lock()
while (self.lecture!=0):
time.sleep(0.1)

tu prends un ticket dans la file d'attente, quand tu la , tu attends que
les autre est fini

Et comment positionnes-tu self.lecture ?

Fais gaffe, terrain glissant ;-)

JKB

c'est le nombres de lecture en cour puisque tu peux faire plusieurs
lecture a la fois contrairement aux écriture

Ce n'est _pas_ la question. Il y a un problème derrière le
positionnement de cette variable. Que tu ne le vois pas est pour le
moins problématique.

JKB

--
Si votre demande me parvient sur carte perforée, je titiouaillerai très
volontiers une réponse...
=> http://grincheux.de-charybde-en-scylla.fr

JKB a écrit :

Le Mon, 10 Jan 2011 14:57:42 +0100,
remy <remy@fctpas.fr> écrivait :

JKB a écrit :

Le Mon, 10 Jan 2011 14:03:36 +0100,
remy <remy@fctpas.fr> écrivait :

Michel Talon a écrit :

Si maintenant il s'agit de synchroniser plusieurs processus, il n'y a
pas de construction de sémaphore possible par des méthode s similaires,
sauf à recourir à des appels systèmes spécifiqu es (sémaphores system V
ou posix) ou des bidouilles via le système de fichiers (cré er des
fichiers verrouillés avec fcntl).

non

def ecriture(self):
self.mutex.lock()
while (self.lecture!=0):
time.sleep(0.1)

tu prends un ticket dans la file d'attente, quand tu la , tu attends que
les autre est fini

Et comment positionnes-tu self.lecture ?

Fais gaffe, terrain glissant ;-)

JKB

c'est le nombres de lecture en cour puisque tu peux faire plusieurs
lecture a la fois contrairement aux écriture

Ce n'est _pas_ la question. Il y a un problème derrière le
positionnement de cette variable. Que tu ne le vois pas est pour le
moins problématique.

JKB

je t'écoute aller ....
remy



--
http://remyaumeunier.chez-alice.fr/

Le Mon, 10 Jan 2011 15:19:07 +0100,
remy <remy@fctpas.fr> écrivait :

JKB a écrit :

Le Mon, 10 Jan 2011 14:57:42 +0100,
remy <remy@fctpas.fr> écrivait :

JKB a écrit :

Le Mon, 10 Jan 2011 14:03:36 +0100,
remy <remy@fctpas.fr> écrivait :

Michel Talon a écrit :

Si maintenant il s'agit de synchroniser plusieurs processus, il n'y a
pas de construction de sémaphore possible par des méthodes similaires,
sauf à recourir à des appels systèmes spécifiques (sémaphores system V
ou posix) ou des bidouilles via le système de fichiers (créer des
fichiers verrouillés avec fcntl).

non

def ecriture(self):
self.mutex.lock()
while (self.lecture!=0):
time.sleep(0.1)

tu prends un ticket dans la file d'attente, quand tu la , tu attends que
les autre est fini

Et comment positionnes-tu self.lecture ?

Fais gaffe, terrain glissant ;-)

JKB

c'est le nombres de lecture en cour puisque tu peux faire plusieurs
lecture a la fois contrairement aux écriture

Ce n'est _pas_ la question. Il y a un problème derrière le
positionnement de cette variable. Que tu ne le vois pas est pour le
moins problématique.

JKB

je t'écoute aller ....
remy

Non. Réfléchis un peu à ce que tu as écrit. Il y a plusieurs
grossières erreurs.

JKB

--
Si votre demande me parvient sur carte perforée, je titiouaillerai très
volontiers une réponse...
=> http://grincheux.de-charybde-en-scylla.fr

JKB a écrit :

Le Mon, 10 Jan 2011 15:19:07 +0100,
remy <remy@fctpas.fr> écrivait :

JKB a écrit :

Le Mon, 10 Jan 2011 14:57:42 +0100,
remy <remy@fctpas.fr> écrivait :

JKB a écrit :

Le Mon, 10 Jan 2011 14:03:36 +0100,
remy <remy@fctpas.fr> écrivait :

Michel Talon a écrit :

Si maintenant il s'agit de synchroniser plusieurs processus, il n 'y a
pas de construction de sémaphore possible par des métho des similaires,
sauf à recourir à des appels systèmes spécifi ques (sémaphores system V
ou posix) ou des bidouilles via le système de fichiers (crà ©er des
fichiers verrouillés avec fcntl).

non

def ecriture(self):
self.mutex.lock()
while (self.lecture!=0):
time.sleep(0.1)

tu prends un ticket dans la file d'attente, quand tu la , tu atten ds que
les autre est fini

Et comment positionnes-tu self.lecture ?

Fais gaffe, terrain glissant ;-)

JKB

c'est le nombres de lecture en cour puisque tu peux faire plusieurs
lecture a la fois contrairement aux écriture

Ce n'est _pas_ la question. Il y a un problème derrière le
positionnement de cette variable. Que tu ne le vois pas est pour le
moins problématique.

JKB

je t'écoute aller ....
remy

Non. Réfléchis un peu à ce que tu as écrit. Il y a plusieurs
grossières erreurs.

mais oui

JKB

--
http://remyaumeunier.chez-alice.fr/