[note: Ho raccolto il nome di questa pagina da un dizionario su internet . Come tale [,questa pagina,]può contenere degli errori, di grammatica o di altro genere. Se tu conosci L' Italiano meglio di me, ti prego di rinominare questa pagina (anche a ritroso,se del caso).]

Titolerei questo programmino = Blocco dei processi = tengo a precisare una cosa: Al fine di poter usare le lettere accentate che nell' orignale del linguaggio inglese non sono riconosciute, e quindi nemmeno nei commenti all'interno del codice, e se lo facessi senza la giusta indicazione il parser segnalerebbe un errore, devo scrivere subito dopo la prima riga, che a tutti è nota e cioè #! /usr/bin/python , questa indicazione: # -*- coding: utf-8 -*- . In tal modo posso tranquillamente usare nei commenti le lettere accentate che si usano nel linguaggio classico Italiano. Aggiungo ancora un messaggio per l'autore di questa pagina mi congratulo per la sua conoscenza dell'Italiano e vorrei prendere contatto con lui per dialogare su python e tutto quanto concerne questo fantastico linguaggio di programmazione. Può scrivermi qui vonkes@gmail.com se vuole. Non entro nel merito del programma che segue ma mi permetterò ,eventualmente, di migliorare quei commenti che, forse, possono risultare poco chiari. Spero di non suscitare i risentimenti dell'autore.

Da questo punto in avanti è tutta opera dell'autore

Inizio questa pagina facendo una domanda. Come si può fermare un processo dall'interno di un altro?

# -*- coding: utf-8 -*-     #   vedi la intestazione di A.CHESSA
#!python
import threading
import time

class Worker(threading.Thread):
  def __init__(self, eventChannel, eventHandler):
    self.eventChannel = eventChannel
    self.eventHandler = eventHandler
    self.stopFlag = 0

  def shutdown(self):
    self.stopFlag = 1

  def run(self):
    self.stopFlag = 0
    while not self.stopFlag:
      event = self.eventChannel.waitEvent()  # blocking call  chiamata del blocco
      self.eventHandler.dispatchEvent(event)


eventChannel = EventChannel()
eventHandler = EventHandler()
worker = Worker(eventChannel, eventHandler)
worker.start()
time.sleep(20)
worker.shutdown()

Il problema è che EventChannel.waitEvent() è una operazione di blocco. Così se l'evento non si verifica, allora il nostro lavoro non si fermerà mai. (EventChannel e EventHandler sono classi che io ho inventato per questo esempio)

Suggerimenti

• Utilizzando il metodo shutdown() si spingono alcuni innocui eventi nell'evento channel

  def shutdown(self):
    self.stopFlag = 1
    self.eventChannel.push_event(NullEvent())

• oppure usando Queue passiamo dei dati . Manipolare gli errori con il manipolatore ( e.g. stampa [print] poi alla console), mantiene vivo il processo

   1 # -*- coding: utf-8 -*-     #   vedi la intestazione di A.CHESSA
   2 import Queue, threading, traceback
   3 
   4 class StopMarker:
   5     """This is used as an individual stopper item.
   6         Uso questo [StopMarker] come un bloccatore individuale
   7     """
   8     
   9 class Worker(threading.Thread):
  10     """Get items from a queue and call the handler with the item.
  11     Errors in the handler are printed to stderr, the thread
  12     continues to run. 
  13         Prende gli articoli da queue e chiama il gestore degli errori con detto articolo.
  14         Gli Errori vengono poi stampati nel stderr dal gestore, il processo continua.  
  15     An individual stop marker is used, so you can pass everyting
  16     as item (including None).
  17     Un singolo marcatore stop è usato ,così pote passere qualunque cosa come articolo
  18     (incluso None).
  19     """
  20     
  21     def __init__(self, handler):
  22         """Initialize Thread object and worker.
  23             Inizializzo l'oggetto e il worker [il lavoratore] 
  24         """
  25         threading.Thread.__init__(self)
  26         self.running = 1
  27         self.handler = handler
  28         self.queue   = Queue.Queue()
  29         self.stopper = StopMarker()
  30     
  31     def run(self):
  32         """Worker loop. Errors in the handler are printed to
  33         stderr and the thread continues with the next item.
  34             Worke cicla. Gli errori sono stampati dal gestore nel stderr 
  35         ed il processo continua con l'articolo successivo.
  36        """
  37         while self.running:
  38             try:
  39                 item = self.queue.get()
  40                 if item is self.stopper:
  41                     break
  42                 else:
  43                     self.handler(item)
  44             except:
  45                 traceback.print_exc()
  46     
  47     def stop(self):
  48         """Stop the worker thread and wait until it terminates.
  49         (Waits until last item is processed)
  50            Ferma il compito del lavoratore e aspetta finchè lui ha terminato
  51         (aspetta fino a che l'ultimo articolo viene processato
  52         """
  53         self.queue.put(self.stopper)    #stopper  item, then...  ferma l'articolo,........  
  54         self.join()                     #wait until the thread has shutdown aspetta finchè il compito è
  55                                            #completato
  56 
  57     def put(self, item):
  58         """Put an item in the queue to be processed by the handler.
  59             Spinge un articolo nella coda e poi lo fa processare dal gestore
  60         """
  61         self.queue.put(item)
  62 
  63 if __name__ == '__main__':
  64     def printer(item):
  65         print "printer(%r)" % item
  66     
  67     w = Worker(printer)
  68     w.start()
  69     for i in range(10):
  70         w.put(i)
  71     w.stop()

Chiamata ad una Funzione "C" che blocca tutti i processi

Ho un modulo in "c" che pone delle interrogazioni al D.B. Queste interrogazioni pongono ad off il server SQLper essere processato.Posso usare delle mie funzioni di interrogazione dentro i processi per avere un lavoro come questo time.sleep(),blocco il corrente processo finchè lui termina ma permette agli altri processi di continuare le operazioni. Non ho visto questi indirizzamenti in nessuno dei libri che possiedo.

Risorse

• Aahz OSCON 2001 presentatione