That’s the gist of first-in, first-out queues, and you can see them everywhere. Waiting for the bus, waiting in front of the elevator or a vending machine, or even standing in line to the bathroom all share one quality - the person standing in the front goes before the one standing behind. Most queues that we encounter throughout the day are FIFO queues. In other words, FIFO queuing is when customers are served in the exact order in which they arrive.įIFO is the most common type of queuing, and it’s generally believed to be the fairest way to manage queues. (FCFS doesn’t roll off the tongue quite as nicely, though.) This is also referred to as the first-come, first-served principle. If you’ve ever read anything about queues or queue management, no doubt you’ve seen this term - FIFO.Ī FIFO queue is a queue that operates on the first-in, first-out principle, hence the name.
#Queue fifo download
Threads will take turns dequeuing URLs to download them.Understanding FIFO: First-In, First-Out in Queue Management The loop below willĬontinue to add items until the feed is exhausted, and the worker Should pick it up and start downloading it. As soonĪs the first URL is added to the queue, one of the worker threads The next step is to retrieve the feed contents (using Mark Pilgrim’sįeedparser module) and enqueue the URLs of the enclosures. Safe to start the threads before there is anything in the queue. Url = q.get() until the queue has something to return, so it is Notice that downloadEnclosures() will block on the statement Once the threads’ target function is defined, we can start the worker Sleeping a variable amount of time, depending on the thread id. In this example, we simulate a download delay by To actuallyĭownload the enclosure, you might use urllib or Illustration purposes this only simulates the download. Will run in the worker thread, processing the downloads. Next, we need to define the function downloadEnclosures() that
#Queue fifo code
For ourĮxample we hard code the number of threads to use and the list of URLs Normally these wouldĬome from user inputs (preferences, a database, whatever). join () print '*** Done'įirst, we establish some operating parameters. print '*** Main thread waiting' enclosure_queue. put ( enclosure ) # Now wait for the queue to be empty, indicating that we have # processed all of the downloads. get ( 'enclosures', ): print 'Queuing:', enclosure enclosure_queue. parse ( url, agent = 'fetch_podcasts.py' ) for entry in response : for enclosure in entry. for url in feed_urls : response = feedparser. start () # Download the feed(s) and put the enclosure URLs into # the queue. task_done () # Set up some threads to fetch the enclosures for i in range ( num_fetch_threads ): worker = Thread ( target = downloadEnclosures, args = ( i, enclosure_queue ,)) worker. get () print ' %s : Downloading:' % i, url # instead of really downloading the URL, # we just pretend and sleep time. """ while True : print ' %s : Looking for the next enclosure' % i url = q. These daemon threads go into an infinite loop, and only exit when the main thread ends. It processes items in the queue one after another. feed_urls = def downloadEnclosures ( i, q ): """This is the worker thread function. # System modules from Queue import Queue from threading import Thread import time # Local modules import feedparser # Set up some global variables num_fetch_threads = 2 enclosure_queue = Queue () # A real app wouldn't use hard-coded data.
0 kommentar(er)
