Basit bir örnek ve bu sorunu kendim halletmem gerektiğinde yararlı bulduğum açıklamalar ile katkıda bulunmak istiyorum.
Bu cevapta Python'un GIL (global tercüman kilidi) hakkında bazı bilgiler ve multiprocessing.dummy ve bazı basit karşılaştırmalar kullanılarak yazılmış basit bir günlük örnek bulacaksınız .
Global Tercüman Kilidi (GIL)
Python, kelimenin tam anlamıyla çoklu iş parçacığına izin vermez. Çok iş parçacıklı bir pakete sahiptir, ancak kodunuzu hızlandırmak için çok iş parçacıklı bir paket istiyorsanız, bunu kullanmak genellikle iyi bir fikir değildir.
Python'un global yorumlayıcı kilidi (GIL) adı verilen bir yapısı vardır. GIL herhangi bir anda 'iş parçacıklarınızdan' yalnızca birinin çalışabilmesini sağlar. Bir iş parçacığı GIL'i alır, küçük bir iş yapar, sonra GIL'i bir sonraki iş parçacığına geçirir.
Bu çok hızlı bir şekilde gerçekleşir, böylece insan gözü için iplikleriniz paralel olarak çalışıyor gibi görünebilir, ancak aynı CPU çekirdeğini kullanarak sırayla.
Tüm bu GIL geçişi yürütmeye ek yük getirir. Bu, kodunuzun daha hızlı çalışmasını istiyorsanız, iş parçacığı paketini kullanmanın genellikle iyi bir fikir olmadığı anlamına gelir.
Python'un iş parçacığı paketini kullanmanın nedenleri var. Bazı şeyleri aynı anda çalıştırmak istiyorsanız ve verimlilik bir endişe kaynağı değilse, tamamen iyi ve kullanışlıdır. Veya bir şey (bazı G / Ç gibi) beklemesi gereken bir kod çalıştırıyorsanız, bu çok mantıklı olabilir. Ancak iş parçacığı kütüphanesi ekstra CPU çekirdeği kullanmanıza izin vermez.
Çoklu iş parçacığı, işletim sistemine (çoklu işlem yaparak) ve Python kodunuzu (örneğin, Spark veya Hadoop ) çağıran bazı harici uygulamalara veya Python kodunuzun çağırdığı bazı kodlara (örneğin: Python kodunuzun pahalı çok iş parçacıklı şeyleri yapan bir C işlevini çağırmasını sağlayın).
Bu Neden Önemli?
Çünkü birçok insan, GIL'in ne olduğunu öğrenmeden önce süslü Python çok iş parçacıklı kodlarında darboğazlar bulmaya çalışırken çok zaman harcıyor.
Bu bilgiler netleştikten sonra işte kodum:
#!/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)
