මම සරල උදාහරණයකින් දායක වීමට කැමැත්තෙමි. මෙම ගැටලුව මා විසින්ම විසඳා ගැනීමට මට සිදු වූ විට පැහැදිලි කිරීම් ප්‍රයෝජනවත් විය.
මෙම පිළිතුරෙන් ඔබට පයිතන්ගේ ජීඅයිඑල් (ගෝලීය පරිවර්තක අගුල) පිළිබඳ තොරතුරු සහ බහු ප්‍රොසෙසින්.ඩම්මි සහ සරල මිණුම් සලකුණු භාවිතා කර ලියා ඇති සරල එදිනෙදා උදාහරණයක් සොයාගත හැකිය .
ගෝලීය පරිවර්තක අගුල (GIL)
වචනයේ සත්‍ය අර්ථයෙන් පයිතන් බහු-නූල් දැමීමට ඉඩ නොදේ. එයට බහු-නූල් පැකේජයක් ඇත, නමුත් ඔබේ කේතය වේගවත් කිරීම සඳහා ඔබට බහු-නූල් කිරීමට අවශ්ය නම්, එය සාමාන්‍යයෙන් එය භාවිතා කිරීම හොඳ අදහසක් නොවේ.
පයිතන්ට ගෝලීය පරිවර්තක අගුල (GIL) නමින් ඉදිකිරීම් ඇත. ඕනෑම වේලාවක ක්රියාත්මක කළ හැක්කේ ඔබගේ 'නූල්' වලින් එකක් පමණක් බව GIL සහතික කරයි. නූල් එකක් GIL ලබා ගනී, සුළු වැඩක් කරයි, පසුව GIL ඊළඟ නූල් වෙත යොමු කරයි.
මෙය ඉතා ඉක්මණින් සිදු වන නිසා මිනිස් ඇසට ඔබේ නූල් සමාන්තරව ක්රියාත්මක වන බවක් පෙනෙන්නට තිබුණත් ඒවා ඇත්ත වශයෙන්ම එකම CPU හරය භාවිතා කරමින් හැරීම් සිදු කරයි.
මේ සියල්ලම GIL පසු කිරීම ක්රියාත්මක කිරීමට ඉහළින් එකතු කරයි. මෙයින් අදහස් කරන්නේ ඔබේ කේතය වේගයෙන් ක්රියාත්මක කිරීමට අවශ්ය නම් නූල් පැකේජය භාවිතා කිරීම බොහෝ විට හොඳ අදහසක් නොවන බවයි.
පයිතන්ගේ නූල් පැකේජය භාවිතා කිරීමට හේතු තිබේ. ඔබට එකවර සමහර දේවල් ක්රියාත්මක කිරීමට අවශ්ය නම්, සහ කාර්යක්ෂමතාව සැලකිලිමත් නොවේ නම්, එය මුළුමනින්ම කදිම සහ පහසුය. නැතහොත් ඔබ යම් දෙයක් සඳහා බලා සිටිය යුතු කේතයක් ධාවනය කරන්නේ නම් (සමහර I / O වැනි) එවිට එය බොහෝ අර්ථවත් කළ හැකිය. නමුත් නූල් පුස්තකාලය මඟින් ඔබට අමතර CPU හර භාවිතා කිරීමට ඉඩ නොදේ.
බහු-නූල් මෙහෙයුම් පද්ධතියට බාහිරින් ලබා ගත හැකිය (බහු සැකසුම් කිරීමෙන්), සහ ඔබේ පයිතන් කේතය (උදාහරණයක් ලෙස ස්පාර්ක් හෝ හැඩූප් ) ලෙස හඳුන්වන සමහර බාහිර යෙදුම් හෝ ඔබේ පයිතන් කේතය ඇමතීමේ සමහර කේත (උදාහරණයක් ලෙස: ඔබට හැකි විය ඔබේ පයිතන් කේතය මිල අධික බහු-නූල් දේවල් කරන C ශ්‍රිතයක් අමතන්න).
ඇයි මේ වැදගත්
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)
