''[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?


{{{

#! /usr/bin/python           
# -*- 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                                                                                                                                                                                           

{{{
#!python
# -*- coding: utf-8 -*-     #   vedi la intestazione di A.CHESSA
import Queue, threading, traceback

class StopMarker:
    """This is used as an individual stopper item.
        Uso questo [StopMarker] come un bloccatore individuale
    """
    
class Worker(threading.Thread):
    """Get items from a queue and call the handler with the item.
    Errors in the handler are printed to stderr, the thread
    continues to run. 
        Prende gli articoli da queue e chiama il gestore degli errori con detto articolo.
        Gli Errori vengono poi stampati nel stderr dal gestore, il processo continua.  
    An individual stop marker is used, so you can pass everyting
    as item (including None).
    Un singolo marcatore stop è usato ,così pote passere qualunque cosa come articolo
    (incluso None).
    """
    
    def __init__(self, handler):
        """Initialize Thread object and worker.
            Inizializzo l'oggetto e il worker [il lavoratore] 
        """
        threading.Thread.__init__(self)
        self.running = 1
        self.handler = handler
        self.queue   = Queue.Queue()
        self.stopper = StopMarker()
    
    def run(self):
        """Worker loop. Errors in the handler are printed to
        stderr and the thread continues with the next item.
            Worke cicla. Gli errori sono stampati dal gestore nel stderr 
        ed il processo continua con l'articolo successivo.
       """
        while self.running:
            try:
                item = self.queue.get()
                if item is self.stopper:
                    break
                else:
                    self.handler(item)
            except:
                traceback.print_exc()
    
    def stop(self):
        """Stop the worker thread and wait until it terminates.
        (Waits until last item is processed)
           Ferma il compito del lavoratore e aspetta finchè lui ha terminato
        (aspetta fino a che l'ultimo articolo viene processato
        """
        self.queue.put(self.stopper)    #stopper  item, then...  ferma l'articolo,........  
        self.join()                     #wait until the thread has shutdown aspetta finchè il compito è
                                           #completato

    def put(self, item):
        """Put an item in the queue to be processed by the handler.
            Spinge un articolo nella coda e poi lo fa processare dal gestore
        """
        self.queue.put(item)

if __name__ == '__main__':
    def printer(item):
        print "printer(%r)" % item
    
    w = Worker(printer)
    w.start()
    for i in range(10):
        w.put(i)
    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 =

 * [[http://starship.python.net/crew/aahz/OSCON2001/index.html|Aahz OSCON 2001 presentatione]]