Synchronisation des Processus sous PYTHON

Bonjour  😉
Je vais essayer de vous montrer comment python gère les processus
concurrents. Pour cela ,nous allons écrire un programme  qui lance deux
processus en parallèles .
Chaque processus a un rôle d’incrémenter le compteur des processus
(self.thread_counter) .
Mais vous risquez d’avoir de grandes surprises si vous vous attendez
que les deux processus incrémentent  le compteur a tour de rôle .
vous risquez d’avoir un truc du genre :

>> : (95257 ,1)
>> : (95257, 2)

Vous voyez bien ici  dans l’exécution  que a  partir d’une certaine certaine
valeur ,les deux processus affichent la même valeurs , bizarre non 😉
En fait c’est très logique , le processus numéro un vient de prendre le compteur
et aussi tôt il l’incrémente , alors que  le processus deux avait déjà pris
le compteur  pour l’incrémenter.
Et comme les deux processus ont incrémenté la même variable (même valeur initiale ) , un seul comptage est
reflété  par la console .

Solution  :
———-

Python , a plusieurs façon de  gérer la concurrence entre les
processus  , mais je suis très séduit par la syntaxe que
je vais vous proposer, il est très simple et très élégant .
>> Utilez le  module lock de Thread
Voici les deux codes  , le premier n’est pas synchrone  , le second  code  l’est  😉

import threading
import sys
import os
import  time
class  ThreadConcurent:

    # The counter loop
    thread_counter = 0

    # Amelioration par rapport au premier
    a_lock  = thread.allocate_lock ()
    def __ini__(self):
         self.running = False

    def thread_first (self):
         """
         This is the first thread , it will be executed
         at the same moment thread  two.
         The  purpose is to see the way the (self.thread_counter) is
         printed  to the prompt
         """
         def fun ():
             while self.running:
                    self.thread_counter +=1
                    print  ("\r\n >> : (%s ,%s)"%(self.thread_counter , "1"))
             return  None
         # Im going  to start the thread
         threading.Thread (target = fun , args =()).start ()

    def thread_second (self):
         def  fun ():
             while self.running:
                with self.a_lock:
                    # Portion de code partagee entre les deux processus
                    # Verouille l'acces au ressource utilise dans  la portion
                    # de ce code au autres processus

                    self.thread_counter +=1
                    print  ("\r\n >> : (%s, %s)"%(self.thread_counter , "2"))
             return None 

         # Im going to start  the thread two
         threading.Thread (target =fun , args = ()).start()

    def start_all_threads  (self):
        print "Starting all threads"
        self.running = True
        self.thread_first ()
        self.thread_second()

    def stop_all_threads (self):
        self.running =False

if __name__=="__main__":

              th_c  =ThreadConcurent ()
              th_c.start_all_threads()

              # Wait anywone need to stop thread
              while (True):
                  try:

                      # Wait  2 second for requested stopping thread
                      time.sleep (2)
                  except KeyboardInterrupt:
                      th_c.running =False
                      print "Stoping  all threads"
                      sys.exit ("Execution stopped")

---
Synchronisation des processus améliorée.
---

import threading
import sys
import os
import time
import thread
class  ThreadConcurent:

    # The counter loop
    thread_counter = 0

    # Amelioration par rapport au premier
    a_lock  = thread.allocate_lock ()
    def __ini__(self):
         self.running = False

    def thread_first (self):
         """
         This is the first thread , it will be executed
         at the same moment thread  two.
         The  purpose is to see the way the (self.thread_counter) is
         printed  to the prompt
         """
         def fun ():
             while self.running:
                # Increment the thread_counter from thread one
                with self.a_lock:
                    # Portion de code partagee entre les deux processus
                    # Verouille l'acces au ressource utilise dans  la portion
                    # de ce code au autres processus

                    self.thread_counter +=1
                    print  ("\r\n >> : (%s ,%s)"%(self.thread_counter , "1"))
             return  None
         # Im going  to start the thread
         threading.Thread (target = fun , args =()).start ()

    def thread_second (self):
         def  fun ():
             while self.running:
                with self.a_lock:
                    # Portion de code partagee entre les deux processus
                    # Verouille l'acces au ressource utilise dans  la portion
                    # de ce code au autres processus

                    self.thread_counter +=1
                    print  ("\r\n >> : (%s, %s)"%(self.thread_counter , "2"))
             return None 

         # Im going to start  the thread two
         threading.Thread (target =fun , args = ()).start()

    def start_all_threads  (self):
        print "Starting all threads"
        self.running = True
        self.thread_first ()
        self.thread_second()

    def stop_all_threads (self):
        self.running =False

if __name__=="__main__":

              th_c  =ThreadConcurent ()
              th_c.start_all_threads()

              # Wait anywone need to stop thread
              while (True):
                  try:

                      # Wait  2 second for requested stopping thread
                      time.sleep (2)
                  except KeyboardInterrupt:
                      th_c.running =False
                      print "Stoping  all threads"
                      sys.exit ("Execution stopped")
import threading
import sys
import os
import  time
class  ThreadConcurent:

# The counter loop
thread_counter = 0

# Amelioration par rapport au premier
a_lock  = thread.allocate_lock ()
def __ini__(self):
self.running = False

def thread_first (self):
«  » »
This is the first thread , it will be executed
at the same moment thread  two.
The  purpose is to see the way the (self.thread_counter) is
printed  to the prompt
«  » »
def fun ():
while self.running:
self.thread_counter +=1
print  (« \r\n >> : (%s ,%s) »%(self.thread_counter , « 1 »))
return  None
# Im going  to start the thread
threading.Thread (target = fun , args =()).start ()

def thread_second (self):
def  fun ():
while self.running:
with self.a_lock:
# Portion de code partagee entre les deux processus
# Verouille l’acces au ressource utilise dans  la portion
# de ce code au autres processus

self.thread_counter +=1
print  (« \r\n >> : (%s, %s) »%(self.thread_counter , « 2 »))
return None

# Im going to start  the thread two
threading.Thread (target =fun , args = ()).start()

def start_all_threads  (self):
print « Starting all threads »
self.running = True
self.thread_first ()
self.thread_second()

def stop_all_threads (self):
self.running =False

if __name__== »__main__ »:

th_c  =ThreadConcurent ()
th_c.start_all_threads()

# Wait anywone need to stop thread
while (True):
try:

# Wait  2 second for requested stopping thread
time.sleep (2)
except KeyboardInterrupt:
th_c.running =False
print « Stoping  all threads »
sys.exit (« Execution stopped »)

Publicités

0 Responses to “Synchronisation des Processus sous PYTHON”



  1. Laisser un commentaire

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s





%d blogueurs aiment cette page :