Как использовать потоки в Python?

import threading   
myHeavyFctThread = threading.Thread(name='myHeavyFunction', target=myHeavyFunction)
f = threading.Thread(name='foreground', target=foreground)

, когда вместо myHeavyFunction Вы передаете имя своего fct и когда необходимо активировать поток:

myHeavyFctThread.start()

я знаю его последнее, но мог бы помочь кому-то: D

Я хотел бы способствовать с простым примером и объяснениями, которые я нашел полезными, когда я должен был заняться этой проблемой сам.

Здесь я вставлю немного полезной информации о GIL и простом повседневном примере (использующий multiprocessing.dummy) и его сравнительные тесты с и без многопоточности.

Глобальная блокировка интерпретатора (GIL)

Python не позволяет многопоточность в самом истинном значении слова. Это имеет пакет многопоточности, но если Вы хотите мультираспараллелить для ускорения кода, тогда это обычно - не хорошая идея использовать его. Python имеет конструкцию, названную Глобальной блокировкой интерпретатора (GIL). GIL удостоверяется, что только один из Ваших 'потоков' может выполниться в любой момент. Поток получает GIL, действительно немного работает, затем передает GIL на следующий поток. Это происходит очень быстро так с человеческим глазом, может казаться, что Ваши потоки выполняются параллельно, но они действительно просто сменяются с помощью того же ядра процессора. Вся эта передача GIL добавляет наверху к выполнению. Это означает, что, если Вы хотите сделать свой код выполненным быстрее тогда с помощью пакета поточной обработки часто, не хорошая идея.

существуют причины использовать пакет поточной обработки Python. Если Вы хотите выполнить некоторые вещи одновременно, и эффективность не является беспокойством, то она прекрасна полностью и удобна. Или если Вы выполняете код, который должен ожидать чего-то (как некоторый IO) тогда, он мог иметь много смысла. Но библиотека поточной обработки не позволит Вам использовать дополнительные ядра процессора.

Многопоточность может быть произведена на стороне к операционной системе (путем выполнения многопроцессорной обработки), некоторое внешнее приложение, которое называет код Python (например, Spark или Hadoop), или некоторый код, который называет код Python (например: у Вас мог быть свой код Python, вызывают функцию C, которая делает дорогой многопоточный материал).

, Почему Это Вопросы

, поскольку много людей проводит много времени, пытаясь найти узкие места в их необычном Python многопоточным кодом, прежде чем они изучат, каков GIL.

, Как только эта информация ясна, вот мой код:

#!/bin/python
from multiprocessing.dummy import Pool
from subprocess import PIPE,Popen
import time
import os

# In the variable pool_size we define the "parallelness".
# For CPU-bound tasks, it doesn't make sense to create more Pool processes
# than you have cores to run them on.
#
# On the other hand, if you are using I/O-bound tasks, it may make sense
# to create a quite a few more Pool processes than cores, since the processes
# will probably spend most their time blocked (waiting for I/O to complete).
pool_size = 8

def do_ping(ip):
    if os.name == 'nt':
        print ("Using Windows Ping to " + ip)
        proc = Popen(['ping', ip], stdout=PIPE)
        return proc.communicate()[0]
    else:
        print ("Using Linux / Unix Ping to " + ip)
        proc = Popen(['ping', ip, '-c', '4'], stdout=PIPE)
        return proc.communicate()[0]


os.system('cls' if os.name=='nt' else 'clear')
print ("Running using threads\n")
start_time = time.time()
pool = Pool(pool_size)
website_names = ["www.google.com","www.facebook.com","www.pinterest.com","www.microsoft.com"]
result = {}
for website_name in website_names:
    result[website_name] = pool.apply_async(do_ping, args=(website_name,))
pool.close()
pool.join()
print ("\n--- Execution took {} seconds ---".format((time.time() - start_time)))

# Now we do the same without threading, just to compare time
print ("\nRunning NOT using threads\n")
start_time = time.time()
for website_name in website_names:
    do_ping(website_name)
print ("\n--- Execution took {} seconds ---".format((time.time() - start_time)))

# Here's one way to print the final output from the threads
output = {}
for key, value in result.items():
    output[key] = value.get()
print ("\nOutput aggregated in a Dictionary:")
print (output)
print ("\n")

print ("\nPretty printed output:")
for key, value in output.items():
    print (key + "\n")
    print (value)

Вот простой пример: вам нужно попробовать несколько альтернативных URL-адресов и вернуть содержимое первого, чтобы ответить.

import Queue
import threading
import urllib2

# Called by each thread
def get_url(q, url):
    q.put(urllib2.urlopen(url).read())

theurls = ["http://google.com", "http://yahoo.com"]

q = Queue.Queue()

for u in theurls:
    t = threading.Thread(target=get_url, args = (q,u))
    t.daemon = True
    t.start()

s = q.get()
print s

Это случай, когда многопоточность используется как простая оптимизация: каждый подпоток ожидает разрешения URL и ответа, чтобы поместить свое содержимое в очередь; каждый поток является демоном (не будет поддерживать процесс, если основной поток завершится - это чаще всего, чем нет); основной поток запускает все подпотоки, делает ли get в очереди, чтобы дождаться, пока один из них не выполнит put , затем передает результаты и завершает работу (что удаляет все подпотоки, которые могут все еще работают, поскольку они являются потоками демонов).

Правильное использование потоков в Python неизменно связано с операциями ввода-вывода (поскольку CPython в любом случае не использует несколько ядер для выполнения задач, связанных с процессором, единственная причина для потоковой передачи - это не блокировка процесса, пока некоторые Ввод / вывод). Очереди почти всегда являются лучшим способом передать работу потокам и / или собрать результаты работы, кстати, и они по своей сути безопасны для потоков, поэтому они избавляют вас от беспокойства о блокировках, условиях, событиях, семафорах и других внутренних -потоковая координация / коммуникационные концепции.

ПРИМЕЧАНИЕ : для фактического распараллеливания в Python вы должны использовать модуль multiprocessing для разделения нескольких процессов, которые выполняются параллельно (из-за глобальной блокировки интерпретатора потоки Python обеспечивают чередование, но они фактически выполняется последовательно, а не параллельно, и полезны только при чередовании операций ввода-вывода).

Однако, если вы просто ищете чередование (или выполняете операции ввода-вывода, которые можно распараллелить, несмотря на глобальную блокировку интерпретатора), то следует начать с модуля threading . В качестве действительно простого примера давайте рассмотрим проблему суммирования большого диапазона путем параллельного суммирования поддиапазонов:

import threading

class SummingThread(threading.Thread):
     def __init__(self,low,high):
         super(SummingThread, self).__init__()
         self.low=low
         self.high=high
         self.total=0

     def run(self):
         for i in range(self.low,self.high):
             self.total+=i


thread1 = SummingThread(0,500000)
thread2 = SummingThread(500000,1000000)
thread1.start() # This actually causes the thread to run
thread2.start()
thread1.join()  # This waits until the thread has completed
thread2.join()
# At this point, both threads have completed
result = thread1.total + thread2.total
print result

Обратите внимание, что приведенный выше пример является очень глупым, поскольку он абсолютно не выполняет операций ввода-вывода и будет выполняться последовательно, хотя и с чередованием ( с дополнительными накладными расходами на переключение контекста) в CPython из-за глобальной блокировки интерпретатора.