পাইথনে থ্রেডিং কীভাবে ব্যবহার করতে পারি?


1277

আমি পাইথনে থ্রেডিং বোঝার চেষ্টা করছি। আমি ডকুমেন্টেশন এবং উদাহরণগুলি দেখেছি, তবে বেশ স্পষ্টভাবে, অনেক উদাহরণ অতিরিক্ত পরিশীলিত এবং সেগুলি বুঝতে আমার সমস্যা হচ্ছে I'm

মাল্টি-থ্রেডিংয়ের জন্য বিভাজনযুক্ত কাজগুলি আপনি কীভাবে স্পষ্টভাবে দেখান?


31
এই বিষয়টির চারপাশে একটি ভাল সাধারণ আলোচনা জেফ নুপের পাইথনের সবচেয়ে কঠিন সমস্যাটি পাওয়া যাবে । সংক্ষেপে, এটি থ্রেডিং প্রাথমিকদের জন্য নয় বলে মনে হয়।
ম্যাথিউ ওয়াকার

111
হাহাহা, আমি ভাবি যে থ্রেডিং সবার জন্য, তবে নতুনরা থ্রেডিংয়ের জন্য নয় :)))))
বোহদান

42
কেবলমাত্র পতাকাঙ্কিত করার জন্য যে লোকেরা সমস্ত উত্তর পড়তে হবে কারণ পরবর্তী ভাষাগুলি যুক্তিযুক্তভাবে আরও উন্নত হওয়ায় নতুন ভাষার বৈশিষ্ট্যগুলি গ্রহণ করা হয়েছে ...
গুইন ইভান্স

5
সিটিতে আপনার মূল যুক্তিটি লিখতে ভুলবেন না এবং পাইথন থ্রেডিংয়ের সত্যিকারের সুবিধা নেওয়ার জন্য এটি টাইপগুলির মাধ্যমে কল করুন।
aaa90210

4
আমি কেবল যুক্ত করতে চেয়েছিলাম যে পাইপবসব থ্রেড প্রবাহকে নিয়ন্ত্রণ করার জন্য বার্তা প্রেরণ এবং গ্রহণ করার এক দুর্দান্ত উপায়
ytpillai

উত্তর:


1416

২০১০ সালে এই প্রশ্নটি জিজ্ঞাসা করা হওয়ার পরে, ম্যাপ এবং পুলের সাহায্যে পাইথনের সাথে কীভাবে সরল মাল্টিথ্রেডিং করা যায় সে বিষয়ে আসল সরলকরণ হয়েছে ।

নীচের কোডটি একটি নিবন্ধ / ব্লগ পোস্ট থেকে এসেছে যা অবশ্যই আপনার চেক আউট করা উচিত (কোনও সম্পর্ক নেই) - এক লাইনে সমান্তরালতা: দিন থেকে দিন থ্রেডিংয়ের কার্যগুলির জন্য একটি সেরা মডেল । আমি নীচে সংক্ষিপ্ত করব - এটি কোডের কয়েকটি লাইন হয়ে শেষ হবে:

from multiprocessing.dummy import Pool as ThreadPool
pool = ThreadPool(4)
results = pool.map(my_function, my_array)

কোনটির বহুবিবাহিত সংস্করণ:

results = []
for item in my_array:
    results.append(my_function(item))

বিবরণ

মানচিত্রটি একটি দুর্দান্ত সামান্য ফাংশন এবং সহজেই আপনার পাইথন কোডে সমান্তরালতা ইনজেক্ট করার মূল চাবিকাঠি। অপরিচিতদের জন্য, ল্যাপের মতো কার্যকরী ভাষা থেকে মানচিত্রটি এমন এক জিনিস যা উত্সাহিত। এটি এমন একটি ফাংশন যা ক্রমগুলির উপরে অন্য ফাংশনকে মানচিত্র করে।

মানচিত্রটি আমাদের জন্য ক্রমটির উপরে পুনরাবৃত্তি পরিচালনা করে, ফাংশনটি প্রয়োগ করে এবং ফলাফলের সবগুলি শেষে একটি কার্যকর তালিকাতে সংরক্ষণ করে।

এখানে চিত্র বিবরণ লিখুন


বাস্তবায়ন

মানচিত্র ফাংশনের সমান্তরাল সংস্করণ দুটি গ্রন্থাগার দ্বারা সরবরাহ করা হয়েছে: মাল্টিপ্রসেসিং এবং এটির সামান্য পরিচিত, তবে সমানভাবে চমত্কার ধাপের শিশু: মাল্টিপ্রসেসিং.ডমি।

multiprocessing.dummyহ'ল মাল্টিপ্রসেসিং মডিউল হিসাবে একই, তবে পরিবর্তে থ্রেড ব্যবহার করে ( একটি গুরুত্বপূর্ণ পার্থক্য - সিপিইউ-নিবিড় কাজের জন্য একাধিক প্রক্রিয়া ব্যবহার করুন; (এবং সময়কালে I / O ) জন্য থ্রেড :

মাল্টিপ্রসেসিং.ডমি মাল্টিপ্রসেসিংয়ের এপিআই প্রতিলিপি করে তবে থ্রেডিং মডিউলটির চারপাশে মোড়কের চেয়ে বেশি কিছু নয় is

import urllib2
from multiprocessing.dummy import Pool as ThreadPool

urls = [
  'http://www.python.org',
  'http://www.python.org/about/',
  'http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html',
  'http://www.python.org/doc/',
  'http://www.python.org/download/',
  'http://www.python.org/getit/',
  'http://www.python.org/community/',
  'https://wiki.python.org/moin/',
]

# Make the Pool of workers
pool = ThreadPool(4)

# Open the URLs in their own threads
# and return the results
results = pool.map(urllib2.urlopen, urls)

# Close the pool and wait for the work to finish
pool.close()
pool.join()

এবং সময় ফলাফল:

Single thread:   14.4 seconds
       4 Pool:   3.1 seconds
       8 Pool:   1.4 seconds
      13 Pool:   1.3 seconds

একাধিক যুক্তি পাস করা ( কেবল পাইথন ৩.৩ এবং এর পরে এটির মতো কাজ করে ):

একাধিক অ্যারে পাস করতে:

results = pool.starmap(function, zip(list_a, list_b))

বা একটি ধ্রুবক এবং একটি অ্যারে পাস:

results = pool.starmap(function, zip(itertools.repeat(constant), list_a))

আপনি যদি পাইথনের পূর্ববর্তী সংস্করণ ব্যবহার করে থাকেন তবে আপনি এই কার্যবিধির মাধ্যমে একাধিক যুক্তি পাস করতে পারেন )।

( সহায়ক মন্তব্যের জন্য ব্যবহারকারী 136036 কে ধন্যবাদ ।)


90
এটি কেবলমাত্র ভোটের অভাবের কারণ এটি এত তাজা পোস্ট করা হয়েছে। এই উত্তরটি সুন্দরভাবে কাজ করে এবং 'মানচিত্রের' কার্যকারিতা প্রদর্শন করে যা এখানে অন্যান্য উত্তরগুলির চেয়ে সিনট্যাক্স বোঝার পক্ষে আরও সহজ করে।
অলস

25
এটি কি থ্রেড এবং প্রক্রিয়া নয়? দেখে মনে হচ্ছে এটি মাল্টিপ্রসেস করার চেষ্টা করে! =
বহুগঠিত

72
যাইহোক, ছেলেরা, আপনি লিখতে with Pool(8) as p: p.map( *whatever* )এবং বুককিপিং লাইনগুলি থেকেও মুক্তি পেতে পারেন।

11
@ বারাফুআলবিনো: এটি যেমন দরকারী, সম্ভবত এটি লক্ষণীয় যে এটি কেবল পাইথন ৩.৩++ এ কাজ করে
fuglede

9
আপনি কীভাবে এই উত্তরটি ছেড়ে যেতে পারেন এবং উল্লেখ করবেন না যে এটি কেবলমাত্র I / O ক্রিয়াকলাপের জন্য দরকারী? এটি কেবলমাত্র একক থ্রেডে চলে যা বেশিরভাগ ক্ষেত্রেই অকেজো এবং এটিকে স্বাভাবিক উপায়ে করা তুলনায় আসলে ধীর
Frobot

714

এখানে একটি সহজ উদাহরণ: আপনাকে কয়েকটি বিকল্প 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

এটি এমন একটি ক্ষেত্রে যেখানে থ্রেডিংটি একটি সাধারণ অপ্টিমাইজেশন হিসাবে ব্যবহৃত হয়: প্রতিটি সাবথ্র্যাডের জন্য ইউআরএলকে সমাধান এবং প্রতিক্রিয়া জানাতে অপেক্ষা করা হয়, যাতে এর বিষয়বস্তুগুলি সারিতে রাখা হয়; প্রতিটি থ্রেডটি একটি ডেমন (মূল থ্রেডটি শেষ হলে প্রক্রিয়াটি ধরে রাখবে না - এটি না হওয়ার চেয়ে বেশি সাধারণ); মূল থ্রেডটি সমস্ত সাব-থ্রেডগুলি শুরু করে get, তাদের মধ্যে একটির কাজ শেষ না হওয়া পর্যন্ত অপেক্ষা করার জন্য কাতারে বসে কী হবে put, তারপরে ফলাফলটি প্রকাশ করে এবং সমাপ্ত হয় (যে কোনও সাবথ্র্যাডগুলি নিচে নিয়ে যায় যা এখনও চলমান রয়েছে, যেহেতু তারা ডেমনের থ্রেড)।

পাইথনের থ্রেডগুলির যথাযথ ব্যবহার অবিচ্ছিন্নভাবে I / O ক্রিয়াকলাপের সাথে সংযুক্ত থাকে (যেহেতু সিপিথন যেভাবেই সিপিইউ-বাউন্ড কার্য পরিচালনা করতে একাধিক কোর ব্যবহার করে না, থ্রেডিংয়ের একমাত্র কারণ প্রক্রিয়াটিকে অবরুদ্ধ করে না যখন কিছু আই / ও-র জন্য অপেক্ষা আছে) )। কাজগুলি থ্রেডগুলিতে কাজ করা এবং / বা কাজের ফলাফলগুলি সংগ্রহের জন্য প্রায় সর্বদাই সর্বোত্তম উপায় এবং সেগুলি স্বতন্ত্রভাবে থ্রেডসেফ হয়, তাই তারা আপনাকে লক, শর্ত, ইভেন্ট, সেমোফোর্স এবং অন্যান্য আন্তঃ সম্পর্কে উদ্বিগ্ন হতে বাঁচায় -উঠার সমন্বয় / যোগাযোগ ধারণা।


10
আবার ধন্যবাদ, মার্টেলিবোট। আমি উদাহরণ আপডেট করেছি সাড়া URL গুলিতে সব জন্য অপেক্ষা করতে: আমদানি সারি, থ্রেডিং, urllib2 কুই = Queue.Queue () URL গুলি = '' ' a.com বিকম । C.com' '' বিভক্ত () urls_received = ০ ডিএফ get_url (q, url): req = urllib2.Request (url) resp = urllib2.urlopen (req) q.put (resp.read ()) গ্লোবাল url_reused url_reused + = 1 মুদ্রণ ইউআরএল_ আপনার ইউআরএল জন্য প্রস্তুত: টি = থ্রেডিং। থ্রেড (টার্গেট = get_url, আরগস = (কিউ, ইউ)) t.daemon = সত্য t.start () যখন q.empty () এবং url_rere << লেন (url): s = q.get () মুদ্রণ গুলি
htmldrum

3
@ জেআরএম: আপনি নীচের পরবর্তী উত্তরটি দেখুন, আমি মনে করি যে থ্রেডগুলি সমাপ্ত না হওয়া পর্যন্ত অপেক্ষা করার আরও ভাল উপায় হ'ল join()পদ্ধতিটি ব্যবহার করা হবে , যেহেতু এটি মূল থ্রেডকে অপেক্ষায় রাখবে যতক্ষণ না তারা ক্রমাগত প্রসেসরের খরচ না করে শেষ না করে মান পরীক্ষা করা হচ্ছে। @ অ্যালেক্স: ধন্যবাদ, থ্রেডগুলি কীভাবে ব্যবহার করতে হয় তা বুঝতে আমার ঠিক এটির দরকার ছিল।
krs013

6
পাইথন 3-এর জন্য, 'আমদানি urllib2' প্রতিস্থাপন করুন 'urlib2 হিসাবে আমদানি urllib.request' দিয়ে। এবং মুদ্রণ বিবৃতিতে প্রথম বন্ধনী রাখুন।
হার্ভে

5
পাইথন 3 এর জন্য Queueমডিউলের নামটি প্রতিস্থাপন করুন queue। পদ্ধতির নাম একই।
জেএসমিথ

2
আমি নোট করেছি যে সমাধানটি কেবল একটি পৃষ্ঠা মুদ্রণ করবে। সারি থেকে উভয় পৃষ্ঠা মুদ্রণের জন্য আবার কমান্ডটি চালান: s = q.get() print s @ krs013 আপনার দরকার নেই joinকারণ কুই.ওয়েট () ব্লক করছে।
টম অ্যান্ডারসন

256

দ্রষ্টব্য : পাইথনে প্রকৃত সমান্তরালনের জন্য আপনার একাধিক প্রক্রিয়া সমান্তরালভাবে চালিত করতে কাঁটাতে মাল্টিপ্রসেসিং মডিউলটি ব্যবহার করা উচিত (গ্লোবাল ইন্টারপ্রেটার লকের কারণে পাইথন থ্রেডগুলি ইন্টারলিভিং সরবরাহ করে, তবে এগুলি আসলে সমান্তরালভাবে নয়, ক্রমিকভাবে সম্পাদিত হয় এবং কেবলমাত্র আই / ও অপারেশনগুলি ইন্টারলিভ করার সময় দরকারী)।

তবে, আপনি যদি কেবল ইন্টারলিভিংয়ের সন্ধান করছেন (বা বিশ্বব্যাপী ইন্টারপ্রেটার লক সত্ত্বেও সমান্তরালভাবে চিহ্নিত I / O ক্রিয়াকলাপগুলি করছেন), তবে থ্রেডিং মডিউলটি শুরু করার জায়গা। সত্যিই একটি সহজ উদাহরণ হিসাবে, আসুন সমান্তরালভাবে সাব্রেনজগুলি যোগ করে একটি বৃহত্তর পরিসরের যোগফলের সমস্যাটি বিবেচনা করুন:

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

নোট করুন যে উপরেরটি একটি অত্যন্ত বোকা উদাহরণ, কারণ এটি পুরোপুরি কোনও আই / ও করে না এবং বৈশ্বিক অনুবাদক লকের কারণে সিপিথনে ইন্টারলিভড (কনটেক্সট স্যুইচিংয়ের অতিরিক্ত ওভারহেড সহ) ক্রমিকভাবে কার্যকর করা হবে।


16
@ অ্যালেক্স, আমি বলিনি যে এটি ব্যবহারিক ছিল, তবে এটি থ্রেড সংজ্ঞায়িত এবং স্প্যান করার পদ্ধতিটি প্রদর্শন করে, যা আমি মনে করি ওপি যা চায় তাই করে।
মাইকেল অ্যারন সাফিয়ান

6
এটি কীভাবে থ্রেডগুলি সংজ্ঞায়িত করতে এবং স্পোন করতে হয় তা দেখায়, এটি আসলে প্যারালজগুলিকে সমান্তরালে সমষ্টি করে না। thread1এটি শেষ না হওয়া পর্যন্ত চলবে যখন মূল থ্রেডটি ব্লক করে, তারপরে একই জিনিসটি ঘটে thread2, তারপরে মূল থ্রেডটি পুনরায় শুরু হয় এবং সেগুলির মানগুলি মুদ্রণ করে।
মার্টিনিউ

তা কি হওয়া উচিত নয় super(SummingThread, self).__init__()? যেমন স্ট্যাকওভারফ্লো
জেমস অ্যান্ড্রেস

@ জেমসএন্ড্রেস, ধরে নিলেন যে "সামিংথ্রেড" থেকে কেউ উত্তরাধিকার সূত্রে আসে না, তবে হয় একজন ভাল কাজ করে; যেমন একটি ক্ষেত্রে সুপার (SummingThread, স্ব) শুধু একটি অভিনব উপায় পদ্ধতি রেজল্যুশন অর্ডার (ম্রো), যা threading.Thread (এবং তারপর পরবর্তীকালে কলিং হয় পরবর্তী ক্লাসে খোঁজা হয় Init উভয় ক্ষেত্রেই যে)। আপনি ঠিক বলেছেন, তবে এটিতে সুপার () ব্যবহার করা বর্তমান পাইথনের জন্য আরও ভাল স্টাইল। সুপারটি তুলনামূলকভাবে সাম্প্রতিক সময়ে আমি এই উত্তরটি সরবরাহ করেছি, অতএব সুপার () ব্যবহার না করে সরাসরি সুপার ক্লাসে সরাসরি কল করা। যদিও সুপারটি ব্যবহার করার জন্য এটি আপডেট করব।
মাইকেল অ্যারন সাফিয়ান

14
সতর্কতা: এই জাতীয় কাজগুলিতে মাল্টিথ্রেডিং ব্যবহার করবেন না! যেমনটি ডেভ বিজলে দেখিয়েছেন: dabeaz.com/python/NewGIL.pdf , 2 সিপিইউতে 2 পাইথন থ্রেড একটি সিপিইউ-ভারী কাজ 1 সিপিইউতে 1 থ্রেডের চেয়ে 2 বার স্লোওয়ার এবং 1 সিপিইউতে 2 টি থ্রেডের চেয়ে 1.5 গুণ স্লোয়ার করে। এই উদ্ভট আচরণটি ওএস এবং পাইথনের মধ্যে প্রচেষ্টার ভুল সমন্বয়জনিত কারণে। থ্রেডগুলির জন্য বাস্তব জীবনের ব্যবহারের ক্ষেত্র হ'ল I / O ভারী কাজ। উদাহরণস্বরূপ যখন আপনি নেটওয়ার্কের মাধ্যমে পড়া / লেখার কাজ সম্পাদন করেন, তখন একটি থ্রেড রাখার অর্থ হয়, ডেটা পড়ার / লেখার জন্য ব্যাকগ্রাউন্ডে অপেক্ষা করে এবং সিপিইউকে অন্য থ্রেডে স্যুইচ করে, যার জন্য ডেটা প্রক্রিয়া করা প্রয়োজন।
বরিস বুর্কভ

98

উল্লিখিত অন্যদের মতো, সিপিথন কেবল জিআইএল-এর জন্য কেবল I / O অপেক্ষার জন্য থ্রেড ব্যবহার করতে পারে ।

আপনি যদি সিপিইউ-আবদ্ধ কাজের জন্য একাধিক কোর থেকে উপকার পেতে চান তবে মাল্টিপ্রসেসিং ব্যবহার করুন :

from multiprocessing import Process

def f(name):
    print 'hello', name

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

33
আপনি কি একটু ব্যাখ্যা করতে পারেন এটি কি করে?
পান্ডিটা

5
@ পান্ডিতা: কোডটি একটি প্রক্রিয়া তৈরি করে, তারপরে এটি শুরু করে। সুতরাং এখন দুটি জিনিস এক সাথে ঘটছে: প্রোগ্রামটির মূল লাইন, এবং প্রক্রিয়াটি যা লক্ষ্য, fফাংশন দিয়ে শুরু হয় । সমান্তরালভাবে, মূল প্রোগ্রামটি এখন প্রক্রিয়াটি প্রস্থান হওয়ার জন্য অপেক্ষা করছে, joinএটির সাথে যুক্ত। যদি প্রধান অংশটি সবে থেকে বেরিয়ে আসে, সাব-প্রসেসটি সম্পূর্ণরূপে চালিত হতে পারে বা নাও পারে, তাই এটি করার joinজন্য সর্বদা সুপারিশ করা হয়।
জনটেলসাল 5

1
একটি বরফী উত্তর অন্তর্ভুক্ত mapফাংশন এখানে: stackoverflow.com/a/28463266/2327328
philshem

2
@philshem করছেন তা নিয়ে সতর্ক খ / লিঙ্কটি আপনি পোস্ট থ্রেডের একটি পুল (প্রক্রিয়াকরণ নয়) এখানে উল্লিখিত ব্যবহার করছে গ stackoverflow.com/questions/26432411/... । তবে এই উত্তরটি একটি প্রক্রিয়া ব্যবহার করছে using আমি এই স্টাফটিতে নতুন, তবে মনে হচ্ছে (জিআইএল এর কারণে) পাইথনে মাল্টথ্রিডিং ব্যবহার করার সময় আপনি কেবল নির্দিষ্ট পরিস্থিতিতে পারফরম্যান্স লাভ পাবেন। তবে, একটি প্রক্রিয়া পুল ব্যবহার করে একটি প্রক্রিয়াতে 1 টিরও বেশি মূল কাজ করে একটি মাল্টিকোর প্রসেসরের সুবিধা নিতে পারে।
ব্যবহারকারী3731622


92

কেবল একটি নোট: থ্রেডিংয়ের জন্য একটি সারি প্রয়োজন হয় না।

এটি আমি কল্পনা করতে পারি এমন সহজ উদাহরণ যা একই সাথে 10 টি প্রক্রিয়া চলমান দেখায়।

import threading
from random import randint
from time import sleep


def print_number(number):

    # Sleeps a random 1 to 10 seconds
    rand_int_var = randint(1, 10)
    sleep(rand_int_var)
    print "Thread " + str(number) + " slept for " + str(rand_int_var) + " seconds"

thread_list = []

for i in range(1, 10):

    # Instantiates the thread
    # (i) does not make a sequence, so (i,)
    t = threading.Thread(target=print_number, args=(i,))
    # Sticks the thread in a list so that it remains accessible
    thread_list.append(t)

# Starts threads
for thread in thread_list:
    thread.start()

# This blocks the calling thread until the thread whose join() method is called is terminated.
# From http://docs.python.org/2/library/threading.html#thread-objects
for thread in thread_list:
    thread.join()

# Demonstrates that the main process waited for threads to complete
print "Done"

3
"এটি হয়ে গেছে" মুদ্রণটি শেষ করতে শেষ উক্তিটি যুক্ত করুন
iChux

1
আমি এই উদাহরণটি মার্তেলির চেয়ে ভাল পছন্দ করি, এটি খেলানো আরও সহজ। যাইহোক, আমি সুপারিশ করব যে প্রিন্ট নাম্বারটি নিম্নলিখিতগুলি করছেন, এটি কী চলছে তা কিছুটা পরিষ্কার করার জন্য: এটি ঘুমানোর আগে র্যান্ডেন্টটি পরিবর্তনশীলটিতে সংরক্ষণ করা উচিত এবং তারপরে "থ্রেড" + স্ট্রিম বলতে মুদ্রণটি পরিবর্তন করা উচিত ( সংখ্যা) + "রেন্টিনটিভেরিয়েবল +" সেকেন্ডের জন্য "ঘুমিয়েছিলেন
নিকোলাই

প্রতিটি থ্রেডটি শেষ হয়ে যাওয়ার সাথে সাথে কি জানার কোনও উপায় আছে?
ম্যাট

1
@ ম্যাট এমন কিছু করার কয়েকটি উপায় রয়েছে তবে এটি আপনার প্রয়োজনের উপর নির্ভর করবে। একটি উপায় হ'ল একটি সিঙ্গলটন বা কিছু অন্যান্য প্রকাশ্যে অ্যাক্সেসযোগ্য ভেরিয়েবল আপডেট করা যা কিছুক্ষণ লুপে দেখা হবে এবং থ্রেডের শেষে আপডেট হবে।
ডগলাস অ্যাডামস

2
দ্বিতীয় forলুপের প্রয়োজন নেই , আপনি thread.start()প্রথম লুপটিতে কল করতে পারেন ।
মিশন মিশন

49

অ্যালেক্স মার্তেলির উত্তর আমাকে সাহায্য করেছিল। তবে, এখানে একটি পরিবর্তিত সংস্করণ রয়েছে যা আমি ভেবেছিলাম আরও দরকারী (কমপক্ষে আমার কাছে)।

আপডেট হয়েছে: পাইথন 2 এবং পাইথন 3 উভয় ক্ষেত্রেই কাজ করে

try:
    # For Python 3
    import queue
    from urllib.request import urlopen
except:
    # For Python 2 
    import Queue as queue
    from urllib2 import urlopen

import threading

worker_data = ['http://google.com', 'http://yahoo.com', 'http://bing.com']

# Load up a queue with your data. This will handle locking
q = queue.Queue()
for url in worker_data:
    q.put(url)

# Define a worker function
def worker(url_queue):
    queue_full = True
    while queue_full:
        try:
            # Get your data off the queue, and do some work
            url = url_queue.get(False)
            data = urlopen(url).read()
            print(len(data))

        except queue.Empty:
            queue_full = False

# Create as many threads as you want
thread_count = 5
for i in range(thread_count):
    t = threading.Thread(target=worker, args = (q,))
    t.start()

6
শুধু ব্যতিক্রম না কেন?
স্ট্যাভ্রোস করোকিঠাকিস

1
আপনি কেবল ব্যক্তিগত পছন্দ করতে পারেন
জিমজেটি

1
আমি কোডটি চালাচ্ছি না, তবে আপনার থ্রেডগুলি ডিমনাইজ করার দরকার নেই? আমি মনে করি যে শেষ-লুপের পরে, আপনার প্রোগ্রামটি প্রস্থান হতে পারে - কমপক্ষে এটি হওয়া উচিত কারণ থ্রেডগুলি এভাবে কাজ করা উচিত work আমি মনে করি একটি ভাল পদ্ধতির মাধ্যমে কর্মীদের ডেটা কাতারে রাখা হয়নি, তবে আউটপুটটিকে একটি কাতারে রাখা হবে কারণ তখন আপনার একটি মেইনলুপ থাকতে পারে যা কেবল শ্রমিকদের কাছ থেকে কাতারে আসা তথ্যকেই পরিচালনা করে না , তবে এখন এটি থ্রেডিংও নয়, এবং আপনি জানেন যে এটি অকাল প্রস্থান করবে না।
dylnmc

1
@ অডিএনএমসি, এটি আমার ব্যবহারের মামলার বাইরে (আমার ইনপুট সারিটি পূর্বনির্ধারিত)। আপনি আপনার রুট যেতে চান, আমি এ খুঁজছেন সুপারিশ করবে সেলারি
JimJty

@ জিমজেটি আপনি কি জানেন যে আমি এই ত্রুটিটি কেন পাচ্ছি: import Queue ModuleNotFoundError: No module named 'Queue'আমি অজগরটি চালিয়ে যাচ্ছি 6. some.৫ কিছু পোস্টে উল্লেখ আছে যে পাইথন ৩.6.৫ এ এটি রয়েছে queueতবে আমি এটি পরিবর্তন করার পরেও এখনও কাজ করে না
ব্যবহারকারী 3৩71656565৪

25

একটি ফাংশন দেওয়া হয়েছে f, এটি এর মত থ্রেড করুন:

import threading
threading.Thread(target=f).start()

যাও তর্ক বিতরণ f

threading.Thread(target=f, args=(a,b,c)).start()

এটা খুব সোজা। থ্রেডগুলি সম্পন্ন করার পরে আপনি কীভাবে তা নিশ্চিত করবেন?
ক্যামেরনরোয়েটায়লর

যতদূর আমি এটি বুঝতে পারি, যখন ফাংশনটি প্রস্থান করে তখন Threadঅবজেক্টটি পরিষ্কার হয়ে যায়। দস্তাবেজগুলি দেখুন । is_alive()আপনার যদি প্রয়োজন হয় তবে থ্রেড চেক করতে আপনি এমন একটি পদ্ধতি ব্যবহার করতে পারেন।
স্টারফ্রি

আমি is_aliveপদ্ধতিটি দেখেছি , তবে কীভাবে এটি থ্রেডে প্রয়োগ করতে পারি তা বুঝতে পারি না। আমি নির্ধারণের চেষ্টা করেছি thread1=threading.Thread(target=f).start()এবং তারপরে এটি যাচাই করে দেখছি thread1.is_alive(), তবে thread1এটি জনবহুল None, তাই সেখানে ভাগ্য নেই। আপনি কি জানেন যে থ্রেড অ্যাক্সেসের অন্য কোনও উপায় আছে কিনা?
ক্যামেরনরোয়েটেলর

4
আপনাকে থ্রেড অবজেক্টটি কোনও ভেরিয়েবলের জন্য বরাদ্দ করতে হবে এবং তারপরে সেই পরিবর্তনশীলটি ব্যবহার করে শুরু করতে হবে: thread1=threading.Thread(target=f)তারপরে অনুসরণ করা হবে thread1.start()। তাহলে আপনি করতে পারেন thread1.is_alive()
স্টারফ্রি

1
কাজ করেছে। এবং হ্যাঁ, নিয়ে পরীক্ষা thread1.is_alive()আয় Falseফাংশন প্রস্থানের যত তাড়াতাড়ি।
ক্যামেরনরোয়েটায়লর

25

আমি এটি খুব দরকারী হিসাবে খুঁজে পেয়েছি: কোর হিসাবে অনেক থ্রেড তৈরি করুন এবং তাদের একটি (বৃহত) সংখ্যক কাজ সম্পাদন করতে দিন (এই ক্ষেত্রে, শেল প্রোগ্রামকে কল করা):

import Queue
import threading
import multiprocessing
import subprocess

q = Queue.Queue()
for i in range(30): # Put 30 tasks in the queue
    q.put(i)

def worker():
    while True:
        item = q.get()
        # Execute a task: call a shell program and wait until it completes
        subprocess.call("echo " + str(item), shell=True)
        q.task_done()

cpus = multiprocessing.cpu_count() # Detect number of cores
print("Creating %d threads" % cpus)
for i in range(cpus):
     t = threading.Thread(target=worker)
     t.daemon = True
     t.start()

q.join() # Block until all tasks are done

@ শাভেনওয়ার্থোগ নিশ্চিত করে যে কোনও একটি তার প্রয়োজনের উপর নির্ভর করে "সিপাস" ভেরিয়েবল সামঞ্জস্য করতে পারে। যাইহোক, সাব-প্রসেস কলটি উপ-প্রক্রিয়াগুলিকে ছড়িয়ে দেবে এবং এগুলি ওএস দ্বারা সিপাস বরাদ্দ করা হবে (পাইথনের "প্যারেন্ট প্রসেস" মানে সাব-প্রসেসগুলির জন্য "একই সিপিইউ" নয়)।
ডলফিন

2
আপনি সঠিক, "থ্রেডগুলি একই সিপিইউতে পিতামাতার প্রক্রিয়া হিসাবে শুরু করা হয়েছে" সম্পর্কে আমার মন্তব্যটি ভুল is জবাবের জন্য ধন্যবাদ!
জনটেলসাল 5

1
সম্ভবত লক্ষণীয় যে মাল্টিথ্রেডিংয়ের বিপরীতে যা একই মেমোরি স্পেস ব্যবহার করে, মাল্টিপ্রসেসিং সহজেই ভেরিয়েবল / ডেটা ভাগ করতে পারে না। যদিও +1
চমত্কার

22

পাইথন 3 এ সমান্তরাল কাজ শুরু করার সুবিধা রয়েছে । এটি আমাদের কাজকে আরও সহজ করে তোলে।

এটা আছে থ্রেড পুলিং এবং প্রক্রিয়া পুলিং

নিম্নলিখিতটি একটি অন্তর্দৃষ্টি দেয়:

থ্রেডপুলএক্সেক্টর উদাহরণ ( উত্স )

import concurrent.futures
import urllib.request

URLS = ['http://www.foxnews.com/',
        'http://www.cnn.com/',
        'http://europe.wsj.com/',
        'http://www.bbc.co.uk/',
        'http://some-made-up-domain.com/']

# Retrieve a single page and report the URL and contents
def load_url(url, timeout):
    with urllib.request.urlopen(url, timeout=timeout) as conn:
        return conn.read()

# We can use a with statement to ensure threads are cleaned up promptly
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    # Start the load operations and mark each future with its URL
    future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
    for future in concurrent.futures.as_completed(future_to_url):
        url = future_to_url[future]
        try:
            data = future.result()
        except Exception as exc:
            print('%r generated an exception: %s' % (url, exc))
        else:
            print('%r page is %d bytes' % (url, len(data)))

প্রসেসপুলএ্যাক্সিকিউটর ( উত্স )

import concurrent.futures
import math

PRIMES = [
    112272535095293,
    112582705942171,
    112272535095293,
    115280095190773,
    115797848077099,
    1099726899285419]

def is_prime(n):
    if n % 2 == 0:
        return False

    sqrt_n = int(math.floor(math.sqrt(n)))
    for i in range(3, sqrt_n + 1, 2):
        if n % i == 0:
            return False
    return True

def main():
    with concurrent.futures.ProcessPoolExecutor() as executor:
        for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
            print('%d is prime: %s' % (number, prime))

if __name__ == '__main__':
    main()

18

জ্বলজ্বলে নতুন কনট্রন্ট.ফিউচার মডিউল ব্যবহার করা

def sqr(val):
    import time
    time.sleep(0.1)
    return val * val

def process_result(result):
    print(result)

def process_these_asap(tasks):
    import concurrent.futures

    with concurrent.futures.ProcessPoolExecutor() as executor:
        futures = []
        for task in tasks:
            futures.append(executor.submit(sqr, task))

        for future in concurrent.futures.as_completed(futures):
            process_result(future.result())
        # Or instead of all this just do:
        # results = executor.map(sqr, tasks)
        # list(map(process_result, results))

def main():
    tasks = list(range(10))
    print('Processing {} tasks'.format(len(tasks)))
    process_these_asap(tasks)
    print('Done')
    return 0

if __name__ == '__main__':
    import sys
    sys.exit(main())

নির্বাহকের পন্থা তাদের সবার কাছে পরিচিত বলে মনে হতে পারে যারা জাভা দিয়ে প্রথমে হাত নষ্ট করেছেন।

পাশাপাশি একদিকে নোট করুন: মহাবিশ্বকে বুদ্ধিমান রাখতে, আপনি যদি withপ্রসঙ্গটি ব্যবহার না করেন তবে আপনার পুলগুলি / নির্বাহকদের বন্ধ করতে ভুলবেন না (এটি এতই দুর্দান্ত যে এটি এটি আপনার জন্য করে)


17

আমার জন্য, থ্রেডিংয়ের নিখুঁত উদাহরণ হ'ল অ্যাসিনক্রোনাস ইভেন্টগুলি পর্যবেক্ষণ করা। এই কোড দেখুন।

# thread_test.py
import threading
import time

class Monitor(threading.Thread):
    def __init__(self, mon):
        threading.Thread.__init__(self)
        self.mon = mon

    def run(self):
        while True:
            if self.mon[0] == 2:
                print "Mon = 2"
                self.mon[0] = 3;

আপনি একটি আইপিথন সেশন খোলার মাধ্যমে এবং এর মতো কিছু করে এই কোডটি খেলতে পারেন:

>>> from thread_test import Monitor
>>> a = [0]
>>> mon = Monitor(a)
>>> mon.start()
>>> a[0] = 2
Mon = 2
>>>a[0] = 2
Mon = 2

অনুগ্রহ করে কয়েক মিনিট অপেক্ষা করুন

>>> a[0] = 2
Mon = 2

1
অ্যাট্রিবিউটআরার: 'মনিটর' অবজেক্টটির কোনও 'স্টপ' নেই?
পান্ডিতা

5
আপনার ইভেন্টটি হওয়ার অপেক্ষায় আপনি কি সিপিইউ চক্রটি সরিয়ে দিচ্ছেন না? সবসময় করা খুব ব্যবহারিক জিনিস নয়।
মোগুল

3
মোগুলের মত, এটি ক্রমাগত কার্যকর করা হবে। কমপক্ষে আপনি একটি স্বল্প ঘুমে যুক্ত করতে পারেন, ঘুম (0.1) বলুন, যা সম্ভবত এর মতো সাধারণ উদাহরণে সিপিইউ ব্যবহারকে উল্লেখযোগ্যভাবে হ্রাস করবে।
চমত্কার

3
এটি একটি ভয়াবহ উদাহরণ, একটি কোর নষ্ট করে। খুব কম সময়ে একটি ঘুম যুক্ত করুন তবে সঠিক সমাধানটি হ'ল কিছু সংকেত-প্রক্রিয়া ব্যবহার করা।
শুদ্ধ

16

বেশিরভাগ ডকুমেন্টেশন এবং টিউটোরিয়ালগুলি পাইথন Threadingএবং Queueমডিউল ব্যবহার করে এবং এটি নতুনদের জন্য অপ্রতিরোধ্য বলে মনে হতে পারে।

সম্ভবত concurrent.futures.ThreadPoolExecutorপাইথন 3 এর মডিউলটি বিবেচনা করুন ।

withধারা এবং তালিকা বোঝার সাথে একত্রিত এটি একটি সত্যই কবজ হতে পারে।

from concurrent.futures import ThreadPoolExecutor, as_completed

def get_url(url):
    # Your actual program here. Using threading.Lock() if necessary
    return ""

# List of URLs to fetch
urls = ["url1", "url2"]

with ThreadPoolExecutor(max_workers = 5) as executor:

    # Create threads
    futures = {executor.submit(get_url, url) for url in urls}

    # as_completed() gives you the threads once finished
    for f in as_completed(futures):
        # Get the results
        rs = f.result()

15

আমি এখানে অনেকগুলি উদাহরণ দেখেছি যেখানে সত্যিকারের কোনও কাজ করা হচ্ছে না এবং সেগুলি বেশিরভাগই সিপিইউ-আবদ্ধ ছিল। এখানে একটি সিপিইউ-বাউন্ডড টাস্কের একটি উদাহরণ রয়েছে যা 10 মিলিয়ন থেকে 10.05 মিলিয়নের মধ্যে সমস্ত মৌলিক সংখ্যাকে গণনা করে। আমি এখানে চারটি পদ্ধতি ব্যবহার করেছি:

import math
import timeit
import threading
import multiprocessing
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor


def time_stuff(fn):
    """
    Measure time of execution of a function
    """
    def wrapper(*args, **kwargs):
        t0 = timeit.default_timer()
        fn(*args, **kwargs)
        t1 = timeit.default_timer()
        print("{} seconds".format(t1 - t0))
    return wrapper

def find_primes_in(nmin, nmax):
    """
    Compute a list of prime numbers between the given minimum and maximum arguments
    """
    primes = []

    # Loop from minimum to maximum
    for current in range(nmin, nmax + 1):

        # Take the square root of the current number
        sqrt_n = int(math.sqrt(current))
        found = False

        # Check if the any number from 2 to the square root + 1 divides the current numnber under consideration
        for number in range(2, sqrt_n + 1):

            # If divisible we have found a factor, hence this is not a prime number, lets move to the next one
            if current % number == 0:
                found = True
                break

        # If not divisible, add this number to the list of primes that we have found so far
        if not found:
            primes.append(current)

    # I am merely printing the length of the array containing all the primes, but feel free to do what you want
    print(len(primes))

@time_stuff
def sequential_prime_finder(nmin, nmax):
    """
    Use the main process and main thread to compute everything in this case
    """
    find_primes_in(nmin, nmax)

@time_stuff
def threading_prime_finder(nmin, nmax):
    """
    If the minimum is 1000 and the maximum is 2000 and we have four workers,
    1000 - 1250 to worker 1
    1250 - 1500 to worker 2
    1500 - 1750 to worker 3
    1750 - 2000 to worker 4
    so let’s split the minimum and maximum values according to the number of workers
    """
    nrange = nmax - nmin
    threads = []
    for i in range(8):
        start = int(nmin + i * nrange/8)
        end = int(nmin + (i + 1) * nrange/8)

        # Start the thread with the minimum and maximum split up to compute
        # Parallel computation will not work here due to the GIL since this is a CPU-bound task
        t = threading.Thread(target = find_primes_in, args = (start, end))
        threads.append(t)
        t.start()

    # Don’t forget to wait for the threads to finish
    for t in threads:
        t.join()

@time_stuff
def processing_prime_finder(nmin, nmax):
    """
    Split the minimum, maximum interval similar to the threading method above, but use processes this time
    """
    nrange = nmax - nmin
    processes = []
    for i in range(8):
        start = int(nmin + i * nrange/8)
        end = int(nmin + (i + 1) * nrange/8)
        p = multiprocessing.Process(target = find_primes_in, args = (start, end))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

@time_stuff
def thread_executor_prime_finder(nmin, nmax):
    """
    Split the min max interval similar to the threading method, but use a thread pool executor this time.
    This method is slightly faster than using pure threading as the pools manage threads more efficiently.
    This method is still slow due to the GIL limitations since we are doing a CPU-bound task.
    """
    nrange = nmax - nmin
    with ThreadPoolExecutor(max_workers = 8) as e:
        for i in range(8):
            start = int(nmin + i * nrange/8)
            end = int(nmin + (i + 1) * nrange/8)
            e.submit(find_primes_in, start, end)

@time_stuff
def process_executor_prime_finder(nmin, nmax):
    """
    Split the min max interval similar to the threading method, but use the process pool executor.
    This is the fastest method recorded so far as it manages process efficiently + overcomes GIL limitations.
    RECOMMENDED METHOD FOR CPU-BOUND TASKS
    """
    nrange = nmax - nmin
    with ProcessPoolExecutor(max_workers = 8) as e:
        for i in range(8):
            start = int(nmin + i * nrange/8)
            end = int(nmin + (i + 1) * nrange/8)
            e.submit(find_primes_in, start, end)

def main():
    nmin = int(1e7)
    nmax = int(1.05e7)
    print("Sequential Prime Finder Starting")
    sequential_prime_finder(nmin, nmax)
    print("Threading Prime Finder Starting")
    threading_prime_finder(nmin, nmax)
    print("Processing Prime Finder Starting")
    processing_prime_finder(nmin, nmax)
    print("Thread Executor Prime Finder Starting")
    thread_executor_prime_finder(nmin, nmax)
    print("Process Executor Finder Starting")
    process_executor_prime_finder(nmin, nmax)

main()

এখানে আমার ম্যাক ওএস এক্স ফোর-কোর মেশিনের ফলাফল রয়েছে

Sequential Prime Finder Starting
9.708213827005238 seconds
Threading Prime Finder Starting
9.81836523200036 seconds
Processing Prime Finder Starting
3.2467174359990167 seconds
Thread Executor Prime Finder Starting
10.228896902000997 seconds
Process Executor Finder Starting
2.656402041000547 seconds

1
@ দ্য ইউএনফুনগেট কোনও প্রসেস এক্সিকিউটিটর সিপিইউ বাউন্ডড টাস্কের থ্রেডিংয়ের চেয়ে অনেক বেশি ভাল
পাইরেটএপ

1
দারুণ উত্তর দোস্ত। আমি নিশ্চিত করতে পারি যে উইন্ডোজ পাইথন ৩. Th-তে (কমপক্ষে) থ্রেডপুলএক্সেকিউটার সিপিইউ-ভারী কাজের জন্য ভাল কিছু করে না। এটি গণনার জন্য কোর ব্যবহার করছে না। যেখানে প্রসেসপুলএ্যাকসিকিউটর প্রতিটি প্রসেসে ডেটা অনুলিপি করে সেখানে বড় ম্যাট্রিক্সের জন্য এটি মারাত্মক।
আনাতোলি আলেক্সিভ

1
খুব দরকারী উদাহরণ, তবে এটি কীভাবে কাজ করেছে তা আমি বুঝতে পারি না। আমরা একটি প্রয়োজন if __name__ == '__main__':অন্যথায় পরিমাপ spawns নিজেই এবং কপি করে প্রিন্ট প্রধান কল করার আগে, প্রচেষ্টা করা হয়েছে আগে একটি নতুন প্রক্রিয়া শুরু করতে ...
স্টেইন

1
@ স্টেইন আমি বিশ্বাস করি যে এটি উইন্ডোজে কেবল একটি সমস্যা।
এএমসি

12

এখানে সিএসভির খুব সাধারণ উদাহরণথ্রেডিং ব্যবহার করে আমদানির । (পাঠাগার অন্তর্ভুক্তি বিভিন্ন উদ্দেশ্যে পৃথক হতে পারে))

সহায়ক কার্যাদি:

from threading import Thread
from project import app
import csv


def import_handler(csv_file_name):
    thr = Thread(target=dump_async_csv_data, args=[csv_file_name])
    thr.start()

def dump_async_csv_data(csv_file_name):
    with app.app_context():
        with open(csv_file_name) as File:
            reader = csv.DictReader(File)
            for row in reader:
                # DB operation/query

ড্রাইভারের কাজ:

import_handler(csv_file_name)

9

আমি যখন এই সমস্যাটি নিজেই মোকাবিলা করতে হয়েছিলাম তখন একটি সাধারণ উদাহরণ এবং আমি যে ব্যাখ্যাগুলি কার্যকর পেয়েছি তার সাথে অবদান রাখতে চাই।

এই উত্তরে আপনি পাইথনের জিআইএল সম্পর্কে কিছু তথ্য পাবেন (গ্লোবাল ইন্টারপ্রেটার লক) এবং মাল্টিপ্রসেসিং.ডমি এবং আরও কিছু সাধারণ মাপদণ্ড ব্যবহার করে লিখিত একটি সাধারণ দিনের উদাহরণস্বরূপ কিছু তথ্য পাবেন।

গ্লোবাল ইন্টারপ্রেটার লক (জিআইএল)

পাইথন শব্দের সত্যিকার অর্থে মাল্টি-থ্রেডিংয়ের অনুমতি দেয় না। এটিতে একটি মাল্টি-থ্রেডিং প্যাকেজ রয়েছে, তবে আপনি যদি নিজের কোডটি গতি বাড়ানোর জন্য মাল্টি-থ্রেড করতে চান তবে সাধারণত এটি ব্যবহার করা ভাল ধারণা নয়।

পাইথনের গ্লোবাল ইন্টারপ্রেটার লক (জিআইএল) নামে একটি নির্মাণ রয়েছে। জিআইএল নিশ্চিত করে যে আপনার 'থ্রেডগুলির মধ্যে একটি' যে কোনও সময়ে কার্যকর করতে পারে। একটি থ্রেড জিআইএল অর্জন করে, সামান্য কাজ করে, তারপরে জিআইএলকে পরবর্তী থ্রেডে প্রেরণ করে।

এটি খুব দ্রুত ঘটে তাই এটি মানুষের চোখের কাছে মনে হয় আপনার থ্রেডগুলি সমান্তরালভাবে সঞ্চালিত হচ্ছে, তবে তারা সত্যিকার অর্থে একই সিপিইউ কোর ব্যবহার করে পালাচ্ছে।

এই সমস্ত জিআইএল পাসিং এক্সিকিউশনে ওভারহেড যুক্ত করে। এর অর্থ হল আপনি যদি আপনার কোডটি দ্রুত চালাতে চান তবে থ্রেডিং প্যাকেজটি প্রায়শই ব্যবহার করা ভাল ধারণা নয়।

পাইথনের থ্রেডিং প্যাকেজটি ব্যবহার করার কারণ রয়েছে। আপনি যদি কিছু জিনিস এক সাথে চালাতে চান, এবং দক্ষতা কোনও উদ্বেগ নয়, তবে এটি সম্পূর্ণ সূক্ষ্ম এবং সুবিধাজনক। অথবা আপনি যদি এমন কোড চালিয়ে যাচ্ছেন যে কোনও কিছুর জন্য অপেক্ষা করতে হবে (কিছু আই / ও এর মতো) তবে এটি প্রচুর পরিমাণে অর্থ বোধ করতে পারে। তবে থ্রেডিং লাইব্রেরি আপনাকে অতিরিক্ত সিপিইউ কোর ব্যবহার করতে দেবে না।

মাল্টি-থ্রেডিং অপারেটিং সিস্টেমে (মাল্টি-প্রসেসিং করে) আউটসোর্স করা যেতে পারে এবং কিছু বাহ্যিক অ্যাপ্লিকেশন যা আপনার পাইথন কোডকে কল করে (উদাহরণস্বরূপ, স্পার্ক বা হ্যাডোপ) ), বা এমন কিছু কোড যা আপনার পাইথন কোড কল করে (উদাহরণস্বরূপ: আপনি পারে আপনার পাইথন কোডটিতে একটি সি ফাংশন কল করুন যা ব্যয়বহুল মাল্টি-থ্রেডযুক্ত জিনিসগুলি করে)।

কেন এই বিষয়গুলি

কারণ জিআইএল কী তা শিখার আগে প্রচুর লোকেরা তাদের অভিনব পাইথন মাল্টি-থ্রেড কোডে বাধা খুঁজে পেতে প্রচুর সময় ব্যয় করে।

এই তথ্যটি পরিষ্কার হয়ে গেলে, আমার কোডটি এখানে:

#!/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)

7

এখানে একটি সাধারণ উদাহরণ সহ মাল্টি থ্রেডিং রয়েছে যা সহায়ক হবে। আপনি এটি চালাতে পারেন এবং সহজেই বুঝতে পারবেন কীভাবে পাইথনে মাল্টি থ্রেডিং কাজ করছে। পূর্ববর্তী থ্রেডগুলির কাজ শেষ না হওয়া পর্যন্ত আমি অন্যান্য থ্রেডে অ্যাক্সেস রোধ করার জন্য একটি লক ব্যবহার করেছি। এই লাইন কোড ব্যবহার করে,

tLock = থ্রেডিং.বাউন্ডসিমাপোর (মান = 4)

আপনি একবারে বেশ কয়েকটি প্রক্রিয়া মঞ্জুর করতে পারেন এবং বাকি থ্রেডগুলি ধরে রাখতে পারেন যা পরে বা শেষ প্রক্রিয়াগুলি পরে চলবে।

import threading
import time

#tLock = threading.Lock()
tLock = threading.BoundedSemaphore(value=4)
def timer(name, delay, repeat):
    print  "\r\nTimer: ", name, " Started"
    tLock.acquire()
    print "\r\n", name, " has the acquired the lock"
    while repeat > 0:
        time.sleep(delay)
        print "\r\n", name, ": ", str(time.ctime(time.time()))
        repeat -= 1

    print "\r\n", name, " is releaseing the lock"
    tLock.release()
    print "\r\nTimer: ", name, " Completed"

def Main():
    t1 = threading.Thread(target=timer, args=("Timer1", 2, 5))
    t2 = threading.Thread(target=timer, args=("Timer2", 3, 5))
    t3 = threading.Thread(target=timer, args=("Timer3", 4, 5))
    t4 = threading.Thread(target=timer, args=("Timer4", 5, 5))
    t5 = threading.Thread(target=timer, args=("Timer5", 0.1, 5))

    t1.start()
    t2.start()
    t3.start()
    t4.start()
    t5.start()

    print "\r\nMain Complete"

if __name__ == "__main__":
    Main()

5

এই পোস্ট থেকে bণ নেওয়ার সাথে সাথে আমরা মাল্টিথ্রেডিং, মাল্টিপ্রসেসিং এবং অ্যাসিঙ্ক / asyncioএবং তাদের ব্যবহারের মধ্যে চয়ন সম্পর্কে জানি ।

সম্মতি এবং সমান্তরালতার জন্য পাইথন 3 এর একটি নতুন অন্তর্নির্মিত গ্রন্থাগার রয়েছে: সমবর্তী : ফিউচার

সুতরাং আমি পদ্ধতিতে চারটি কাজ (অর্থাত্ .sleep()পদ্ধতি) চালানোর জন্য একটি পরীক্ষার মাধ্যমে প্রদর্শন করব Threading-Pool:

from concurrent.futures import ThreadPoolExecutor, as_completed
from time import sleep, time

def concurrent(max_worker=1):
    futures = []

    tick = time()
    with ThreadPoolExecutor(max_workers=max_worker) as executor:
        futures.append(executor.submit(sleep, 2))  # Two seconds sleep
        futures.append(executor.submit(sleep, 1))
        futures.append(executor.submit(sleep, 7))
        futures.append(executor.submit(sleep, 3))

        for future in as_completed(futures):
            if future.result() is not None:
                print(future.result())

    print('Total elapsed time by {} workers:'.format(max_worker), time()-tick)

concurrent(5)
concurrent(4)
concurrent(3)
concurrent(2)
concurrent(1)

আউটপুট:

Total elapsed time by 5 workers: 7.007831811904907
Total elapsed time by 4 workers: 7.007944107055664
Total elapsed time by 3 workers: 7.003149509429932
Total elapsed time by 2 workers: 8.004627466201782
Total elapsed time by 1 workers: 13.013478994369507

[ দ্রষ্টব্য ]:

  • আপনি উপরের ফলাফলগুলিতে দেখতে পাচ্ছেন, সেরা কেসটি ছিল 3 চারটি কাজের জন্য কর্মী workers
  • আপনার যদি আই / ও বাউন্ড বা ব্লক ( multiprocessingবনাম threading) এর পরিবর্তে কোনও প্রক্রিয়া টাস্ক থাকে তবে আপনি এতে পরিবর্তন করতে ThreadPoolExecutorপারেন ProcessPoolExecutor

4

পূর্ববর্তী কোনও সমাধানই আসলে আমার জিএনইউ / লিনাক্স সার্ভারে (যেখানে আমার প্রশাসকের অধিকার নেই) একাধিক কোর ব্যবহৃত হয়নি। তারা কেবল একটি একক কোর উপর দৌড়ে।

আমি os.forkএকাধিক প্রক্রিয়া স্প্যান করতে নিম্ন স্তরের ইন্টারফেস ব্যবহার করেছি । এই কোডটি আমার পক্ষে কাজ করেছে:

from os import fork

values = ['different', 'values', 'for', 'threads']

for i in range(len(values)):
    p = fork()
    if p == 0:
        my_function(values[i])
        break

2
import threading
import requests

def send():

  r = requests.get('https://www.stackoverlow.com')

thread = []
t = threading.Thread(target=send())
thread.append(t)
t.start()

1
@ এসপি_আমি অনুমান করছি কারণ তখন আপনার কাছে থ্রেড অবজেক্ট রয়েছে যাতে আপনি তাদের সমাপ্ত হওয়ার জন্য অপেক্ষা করতে পারেন।
আলেকসন্দর মাকরগিć

1
t = থ্রেডিং। থ্রেড (টার্গেট = প্রেরণ ()) টি = থ্রেডিং হওয়া উচিত
h

আমি এই উত্তরটিকে নিম্নমানের করছি কারণ এটি একটি গুরুতর ভুলত্রুটি থাকা ছাড়াও বিদ্যমান উত্তরগুলিতে কীভাবে উন্নতি হয় তার ব্যাখ্যা সরবরাহ করে না।
জুলাই
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.