Python-Warteschlangenmodul

In diesem Artikel wird hauptsächlich das Python-Warteschlangenmodul vorgestellt. Freunde, die es benötigen, können darauf verweisen.

In Python ist die Warteschlange die am häufigsten verwendete Form des Datenaustauschs zwischen Threads. Das Warteschlangenmodul ist ein Modul, das Warteschlangenoperationen bereitstellt. Obwohl es einfach und benutzerfreundlich ist, können dennoch einige Unfälle passieren, wenn Sie nicht vorsichtig sind.

Erstellen Sie ein „Warteschlangen“-Objekt
Import Queue
q = Queue.Queue(maxsize = 10)
Queue.Queue-Klasse, d. h. Es handelt sich um eine synchrone Implementierung einer Warteschlange. Die Warteschlangenlänge kann unendlich oder endlich sein. Die Warteschlangenlänge kann über den optionalen Parameter maxsize des Warteschlangenkonstruktors festgelegt werden. Wenn maxsize kleiner als 1 ist, bedeutet dies, dass die Warteschlangenlänge unbegrenzt ist.

Fügen Sie einen Wert in die Warteschlange ein
q.put(10)
Rufen Sie die put()-Methode des Warteschlangenobjekts auf, um einen Wert einzufügen am Ende des Warteschlangenprojekts. put() verfügt über zwei Parameter. Das erste Element ist der Wert des eingefügten Elements. Der zweite Block ist ein optionaler Parameter und der Standardwert ist
1. Wenn die Warteschlange derzeit leer ist und der Block 1 ist, bewirkt die Methode put(), dass der aufrufende Thread anhält, bis eine Dateneinheit frei ist. Wenn Block 0 ist, löst die Put-Methode eine Full-Ausnahme aus.

Entfernen Sie einen Wert aus der Warteschlange
q.get()
Rufen Sie die Methode get() des Warteschlangenobjekts auf, um ihn aus der Warteschlange zu löschen An die Spitze der Warteschlange treten und ein Projekt zurückgeben. Der optionale Parameter ist block, der standardmäßig True ist. Wenn die Warteschlange leer ist und der Block „True“ ist, bewirkt get(), dass der aufrufende Thread anhält, bis ein Element verfügbar ist. Wenn die Warteschlange leer ist und der Block den Wert False hat, löst die Warteschlange eine Empty-Ausnahme aus.

Das Python-Warteschlangenmodul verfügt über drei Warteschlangen und Konstruktoren:
1 Die FIFO-Warteschlange des Python-Warteschlangenmoduls ist „First In, First Out“. Klasse Queue.Queue(maxsize)
2. LIFO ähnelt einem Heap, das heißt, zuerst rein, zuletzt raus. Klasse Queue.LifoQueue(maxsize)
3. Es gibt eine andere Methode, bei der die Priorität umso höher ist, je niedriger sie ist. Klasse Queue.PriorityQueue(maxsize)

Gemeinsame Methoden in diesem Paket (q = Queue.Queue()):
q.qsize() Return The Größe der Warteschlange
q.empty() Wenn die Warteschlange leer ist, geben Sie True zurück, andernfalls False
q.full() Wenn die Warteschlange voll ist, geben Sie True zurück, andernfalls False
q.full entspricht die maximale Größe
q.get([block[, timeout]]) Ruft die Warteschlange ab, Timeout-Wartezeit
q.get_nowait() ist äquivalent zu q.get(False)
nicht blockierendes q. put(item) schreibt in die Warteschlange, Timeout-Wartezeit
q.put_nowait(item) entspricht q.put(item, False)
q.task_done() Nach Abschluss eines Jobs wird q.task_done( )-Funktion sendet ein Signal
q.join() bedeutet eigentlich, zu warten, bis die Warteschlange leer ist, bevor andere Vorgänge ausgeführt werden

Beispiel:
Implementieren von a Thread kontinuierlich Generieren Sie eine Zufallszahl in einer Warteschlange (erwägen Sie die Verwendung des Warteschlangenmoduls)
Implementieren Sie einen Thread, um kontinuierlich ungerade Zahlen aus der obigen Warteschlange zu entnehmen
Implementieren Sie einen anderen Thread, um kontinuierlich gerade Zahlen aus der obigen Warteschlange zu entnehmen

#!/usr/bin/env python
#coding:utf8
import random,threading,time
from Queue import Queue
#Producer thread
class Producer(threading.Thread):
  def __init__(self, t_name, queue):
    threading.Thread.__init__(self,name=t_name)
    self.data=queue
  def run(self):
    for i in range(10):  #随机产生10个数字 ，可以修改为任意大小
      randomnum=random.randint(1,99)
      print "%s: %s is producing %d to the queue!" % (time.ctime(), self.getName(), randomnum)
      self.data.put(randomnum) #将数据依次存入队列
      time.sleep(1)
    print "%s: %s finished!" %(time.ctime(), self.getName())
 
#Consumer thread
class Consumer_even(threading.Thread):
  def __init__(self,t_name,queue):
    threading.Thread.__init__(self,name=t_name)
    self.data=queue
  def run(self):
    while 1:
      try:
        val_even = self.data.get(1,5) #get(self, block=True, timeout=None) ,1就是阻塞等待,5是超时5秒
        if val_even%2==0:
          print "%s: %s is consuming. %d in the queue is consumed!" % (time.ctime(),self.getName(),val_even)
          time.sleep(2)
        else:
          self.data.put(val_even)
          time.sleep(2)
      except:   #等待输入，超过5秒 就报异常
        print "%s: %s finished!" %(time.ctime(),self.getName())
        break
class Consumer_odd(threading.Thread):
  def __init__(self,t_name,queue):
    threading.Thread.__init__(self, name=t_name)
    self.data=queue
  def run(self):
    while 1:
      try:
        val_odd = self.data.get(1,5)
        if val_odd%2!=0:
          print "%s: %s is consuming. %d in the queue is consumed!" % (time.ctime(), self.getName(), val_odd)
          time.sleep(2)
        else:
          self.data.put(val_odd)
          time.sleep(2)
      except:
        print "%s: %s finished!" % (time.ctime(), self.getName())
        break
#Main thread
def main():
  queue = Queue()
  producer = Producer('Pro.', queue)
  consumer_even = Consumer_even('Con_even.', queue)
  consumer_odd = Consumer_odd('Con_odd.',queue)
  producer.start()
  consumer_even.start()
  consumer_odd.start()
  producer.join()
  consumer_even.join()
  consumer_odd.join()
  print 'All threads terminate!'
 
if __name__ == '__main__':
  main()

           

Das obige ist der detaillierte Inhalt vonPython-Warteschlangenmodul. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!