Публикации с меткой «threading»

Как организовать пул потоков? Допустим у меня есть 100 данных (пусть они находятся в каком-либо списке) и все их нужно переработать в 10 потоков. Стартуем 10 потоков, в каждый передаем по 1 данному, следим за потоками, как только один отработал, стартуем новый и так пока не кончатся данные… В общем, это не то, чтобы бред, но есть способ поудобней.

За всё время работы скрипта, стартует только 10 потоков, просто каждый из них, отработав со своим 1 данным, не дохнет, а берет из списка следующее 1 данное и делает с ним эту же работу:

# -*- coding: utf-8 -*-
import threading, Queue, time
import traceback

class Worker(threading.Thread):
    def __init__(self,queue):
        threading.Thread.__init__(self)
        self.__queue = queue

    def run(self):
        while True:

            try: item = self.__queue.get_nowait() # ждём данные
            except Queue.Empty: break # данные закончились, прекращаем работу

            try: self.work(item) # работа
            except Exception: traceback.print_exc()

            time.sleep(0.5)
            self.__queue.task_done() # задача завершена
        return
    def work(self,item):
        print item
        #pass

def main():
    # Выводим в 5 потоков цифры от 1 до 100.
    queue = Queue.Queue()
    num_threads = 5 # 5 потоков

    for x in xrange(100):
        queue.put(x) # заносим данные в очередь
    for i in xrange(num_threads):
        t = Worker(queue) # создаем поток
        t.start() # стартуем
        time.sleep(0.1) # чтобы в консоли друг на друга не накладывались

    queue.join() #блокируем выполнение программы, пока не будут израсходованы данные.

    print "Done!"
if __name__ == '__main__':
    main()

И, в общем, хотелось бы еще, чтобы можно всё это в любой момент можно было бы остановить. Но поскольку мы выполнение программы блокируем с помощью queue.join(), то скрипт наши Ctr+C банально «не услышит». Я начал искать, что делать в таком случае, нашел вот такое решение, но у меня оно работало абы как. А потом, поразмыслив, я сам придумал решение, которое оказалось ужасно простым.

# -*- coding: utf-8 -*-
import threading, Queue, time
import traceback

class Worker(threading.Thread):
    def __init__(self,queue):
        threading.Thread.__init__(self)
        self.__queue = queue

        self.kill_received = False # флаг прекращения работы
    def run(self):
        while not self.kill_received:

            try: item = self.__queue.get_nowait() # ждём данные
            except Queue.Empty: break

            try: self.work(item)
            except Exception: traceback.print_exc()

            time.sleep(0.5)
            self.__queue.task_done() # задача завершена
            self.__queue.put(item) # зациклим
        return
    def work(self,item):
        print item

def main():
    queue = Queue.Queue()
    num_threads = 5 # 5 потоков

    threads = []
    for x in xrange(100):
        queue.put(x) # заносим данные в очередь
    for i in xrange(num_threads):
        t = Worker(queue) # создаем нить
        threads.append(t)
        t.start() # стартуем
        time.sleep(0.1)

    #Пока в "живых" не останется только главный поток, ждем.
    while threading.activeCount()>1:
        try:
            time.sleep(1)
        except KeyboardInterrupt:
            print "Ctrl-c received! Sending kill to threads..."
            for t in threads:
                t.kill_received = True # даем сигнал о завершении всем потокам
    print "Done!"
if __name__ == '__main__':
    main()

Я думаю,  пример из SEO-софта на тему пула потоков долго искать не придется. Взять тот же Хрумер. Указал количество потоков, например 20, запустил – все 20 работают, как только один из них завершит работу – запускается следующий и так, пока не закончатся ссылки. Наверное в 9 из 10 случаев я пишу скрипт с использованием пула потоков.  Рассмотрим некторые примеры.

Пример 1. «В лоб».

    threads = []
    for x in range(THREADS):
        new_thread = threading.Thread(target=step_one)
        threads.append(new_thread)
        new_thread.start()
        time.sleep(1)
    while True: # какое-то условие
        for y in threads[:]:
            if not y.isAlive():
                threads.remove(y)
                new_thread = threading.Thread(target=step_one)
                threads.append(new_thread)
                new_thread.start()
        time.sleep(0.1)
    while threading.activeCount()>0:
        time.sleep(5)

Функцию step_one запускаем в несколько потоков, все созданные потоки храним в списке. Затем провереяем в цикле какие потоки завершили работу и, если такие есть, создаем новые и так, пока не достигнем какого-либо результата. Криво, неудобно, зато сразу понятно. Достаточно долго пользовался такой реализацией, а всё из-за лени.

Пример 2. Семафоры.

import time
import threading
max_potokov = 20
maxconnections = 5
akkiQueue = threading.BoundedSemaphore(value=maxconnections)

def doform():
    akkiQueue.acquire()
    # код функции
    akkiQueue.release()

for i in xrange(max_potokov):
    time.sleep(1)
    p = threading.Thread(target=doform)
    p.setDaemon(True)
    p.start()
while threading.activeCount()>0:
    time.sleep(5)

Уже лучше, количество потоков контролируется, но надо заранее знать сколько будет потоков, в общем как-то изворачиваться если тебе надо будет прервать все эти потоки по условию.

Пример 3. Очереди.

queue = Queue.Queue() # создаем очередь

def register():
    '''Функция с основным кодом'''
    return
def repeat():
    while True:
        try:
            item = queue.get_nowait() # ждём данные
        except Queue.Empty:
            break
        register(item) # передаем данные в нашу функцию
        time.sleep(0.5)
        queue.task_done() # задача завершена
for i in range(MAX_THREADS):
    queue.put(item) # заносим данные в очередь
for i in xrange(THREADS):
    t = threading.Thread(target=repeat) # создаем нить
    t.start() # стартуем
    time.sleep(0.5)
queue.join() # блокируем очередь до завершения

Здесь используется модуль Queue. На данный для меня самый удобный варинат – и выглядит красиво, и данные передавать можно.

Помимо тех вариантов, что я описал, можно погуглить на тему threadpool и найти какие-нибудь модули для организации пула потоков.