ما هي المعالجة المتعددة في لغة بايثون وكيفية تحقيقها؟

الوقت هو أهم عامل في الحياة. نظرًا لأهميته ، يوفر عالم البرمجة العديد من الحيل والتقنيات التي تساعدك بشكل كبير على تقليل استهلاك الوقت ، وبالتالي زيادة الأداء. أحد هذه الأساليب هو Multithreading في Python ، وهو أحد أهم المفاهيم التي يغطيها .

فيما يلي ملخص سريع لجميع التخصصات التي تم تناولها في هذا المقال:

ما هو تعدد المهام في بايثون؟
ما هو الخيط؟
ما هو تعدد الخيوط في بيثون؟
متى تستخدم multithreading في بايثون؟
كيف تحقق تعدد مؤشرات الترابط في بايثون؟
كيف تصنع المواضيع في بايثون؟

• دون إنشاء فصل دراسي
• من خلال تمديد فئة الموضوع
• بدون تمديد فئة الخيط

مزايا استخدام multithreading في بايثون

بادئ ذي بدء ، دعونا نحاول أولاً فهم تعدد المهام قبل أن نبدأ في التعرف على تعدد مؤشرات الترابط في بايثون.

البدء مع mysql workbench

ما هو تعدد المهام في بايثون؟

تعدد المهام ، بشكل عام ، هو القدرة على أداء مهام متعددة في وقت واحد. من الناحية الفنية ، يشير تعدد المهام إلى قدرة نظام التشغيل على أداء مهام مختلفة في نفس الوقت. على سبيل المثال ، فأنت تقوم بتنزيل شيء ما على جهاز الكمبيوتر الخاص بك بالإضافة إلى الاستماع إلى الأغاني وتشغيل لعبة في نفس الوقت ، وما إلى ذلك. يتم تنفيذ جميع هذه المهام بواسطة نفس نظام التشغيل ومتزامن. هذا ليس سوى تعدد المهام الذي لا يساعدك فقط على توفير الوقت بل يزيد أيضًا من الإنتاجية.

هناك نوعان من تعدد المهام في نظام التشغيل:

• القائم على العملية
• الخيط القائم

في هذه المقالة سوف تتعلم الخيط القائم تعدد المهام أو تعدد .

ما هو الخيط؟

الخيط هو في الأساس ملف مستقل تدفق التنفيذ. يمكن أن تتكون عملية واحدة من خيوط متعددة. كل خيط في برنامج يؤدي مهمة معينة. فمثلا، عندما تلعب لعبة ، قل FIFA على جهاز الكمبيوتر الخاص بك ، فإن اللعبة ككل هي عملية واحدة و لكنها تتكون من عدة خيوط مسؤولة عن تشغيل الموسيقى ، وأخذ مدخلات من المستخدم ، وتشغيل الخصم بشكل متزامن ، وما إلى ذلك. كل هذه خيوط منفصلة مسؤولة عن تنفيذ هذه المهام المختلفة في نفس البرنامج.

كل عملية لها خيط واحد يعمل دائمًا. هذا هو الخيط الرئيسي. هذا الخيط الرئيسي يقوم بالفعل بإنشاء كائنات الخيط الفرعية. يبدأ الخيط الفرعي أيضًا بواسطة الخيط الرئيسي. سأوضح لكم جميعًا في هذه المقالة كيفية التحقق من موضوع التشغيل الحالي.

مع هذا ، أتمنى أن تكون قد فهمت بوضوح ما هو الخيط. المضي قدما ، دعونا نرى ما هو تعدد مؤشرات الترابط في بايثون.

متى تستخدم Multithreading في Python؟

تعد ميزة Multithreading مفيدة جدًا لتوفير الوقت وتحسين الأداء ، ولكن لا يمكن تطبيقها في كل مكان.
في مثال FIFA السابق ، يكون الخيط الموسيقي مستقلاً عن الخيط الذي يأخذ مدخلاتك والخيط الذي يأخذ مدخلاتك مستقل عن الخيط الذي يدير خصمك. تعمل هذه الخيوط بشكل مستقل لأنها لا تعتمد على بعضها البعض.

لذلك ، لا يمكن استخدام تعدد مؤشرات الترابط إلا في حالة عدم وجود تبعية بين سلاسل العمليات الفردية.

توضح هذه المقالة أيضًا كيف يمكنك تحقيق تعدد مؤشرات الترابط في بايثون.

كيف تحقق تعدد مؤشرات الترابط في بايثون؟

يمكن تحقيق تعدد مؤشرات الترابط في بايثون عن طريق استيراد ملف خيوط وحدة.

قبل استيراد هذه الوحدة ، يجب عليك تثبيتها. لتثبيت هذا على بيئة أناكوندا الخاصة بك ، قم بتنفيذ الأمر التالي في موجه الأناكوندا الخاص بك:

تثبيت conda -c conda-forge tbb

بعد تثبيته بنجاح ، يمكنك استخدام أي من الأوامر التالية لاستيراد وحدة الترابط:

استيراد خيوط من استيراد الخيوط *

الآن بعد أن قمت بتثبيت وحدة الترابط ، دعنا نمضي قدمًا ونقوم بعمل Multithreading في Python.

كيف تصنع المواضيع في بايثون؟

يمكن إنشاء الخيوط في Python بثلاث طرق:

1. بدون إنشاء فصل دراسي
2. من خلال تمديد فئة الموضوع
3. بدون تمديد فئة الموضوع

بدون إنشاء فصل دراسي

يمكن إجراء تعدد مؤشرات الترابط في بايثون بدون إنشاء فئة أيضًا. فيما يلي مثال لتوضيح ذلك:

مثال:

من استيراد الخيط * print (current_thread (). getName ()) def mt (): print ('Child Thread') child = Thread (target = mt) child.start () print ('Executing thread name:'، current_thread ( ) .getName ())

انتاج:

MainThread Child Thread تنفيذ اسم الموضوع: MainThread

يوضح الإخراج أعلاه أن الخيط الأول الموجود هو الخيط الرئيسي. يقوم هذا الخيط الرئيسي بعد ذلك بإنشاء مؤشر ترابط فرعي يقوم بتنفيذ الوظيفة ثم يتم تنفيذ جملة الطباعة النهائية مرة أخرى بواسطة مؤشر الترابط الرئيسي.

الآن دعونا نمضي قدمًا ونرى كيفية عمل Multithreading في python من خلال توسيع فئة Thread.

بتوسيع فئة مؤشر الترابط:

عند إنشاء فئة تابعة عن طريق توسيع فئة مؤشر الترابط ، تمثل الفئة التابعة أن مؤشر ترابط جديد يقوم بتنفيذ بعض المهام. عند تمديد فئة Thread ، يمكن للفئة الفرعية تجاوز طريقتين فقط ، أي طريقة __init __ () وطريقة run (). لا يمكن تجاوز أي طريقة أخرى بخلاف هاتين الطريقتين.

فيما يلي مثال على كيفية توسيع فئة Thread لإنشاء سلسلة رسائل:

مثال:

استيراد مؤشر ترابط وقت الاستيراد لفئة mythread (threading.Thread): def run (self): for x in range (7): print ('Hi from child') a = mythread () a.start () a.join () print ('وداعًا من'، current_thread (). getName ())

انتاج:
مرحبًا من الطفل
مرحبًا من الطفل
مرحبًا من الطفل
مرحبًا من الطفل
مرحبًا من الطفل
مرحبًا من الطفل
مرحبًا من الطفل
وداعا من MainThread

يوضح المثال أعلاه أن الفئة myclass ترث فئة Thread والفئة الفرعية ، أي أن myclass يتجاوز طريقة التشغيل. بشكل افتراضي ، يجب أن تكون المعلمة الأولى لأي وظيفة فئة هي مؤشر الذات وهو المؤشر إلى الكائن الحالي. يُظهر الإخراج أن مؤشر الترابط الفرعي ينفذ طريقة run () وينتظر مؤشر الترابط الرئيسي حتى يكتمل تنفيذ العناصر الفرعية. هذا بسبب وظيفة الانضمام () ، التي تجعل الخيط الرئيسي ينتظر حتى ينتهي الطفل.

هذه الطريقة في إنشاء الخيوط هي الطريقة الأكثر تفضيلاً لأنها الطريقة القياسية. ولكن في حالة رغبتك في إنشاء سلاسل رسائل دون وراثة فئة مؤشر الترابط أو توسيعها ، يمكنك القيام بذلك بالطريقة التالية.

بدون تمديد فئة الموضوع

لإنشاء سلسلة محادثات بدون توسيع فئة الموضوع ، يمكنك القيام بما يلي:
مثال:

من استيراد الترابط * فئة ex: def myfunc (self): #self كمعامل أول في فئة func لـ x في النطاق (7): print ('Child') myobj = ex () thread1 = Thread (target = myobj. myfunc) thread1.start () thread1.join () طباعة ('تم')

انتاج:

طفل
طفل
طفل
طفل
طفل
طفل
طفل
فعله

مزايا استخدام الخيوط

تعدد العمليات له مزايا عديدة منها ما يلي:

• استخدام أفضل للموارد
• يبسط الكود
• يسمح بحدوث متزامن ومتوازي لمختلف المهام
• يقلل من استهلاك الوقت أو وقت الاستجابة ، وبالتالي زيادة الأداء.

فيما يلي مثال للتحقق من الوقت الذي يستغرقه تنفيذ التعليمات البرمجية باستخدام أو بدون تعدد مؤشرات الترابط في بيثون:

 مثال: 

وقت الاستيراد def sqr (n): لـ x in n: time.sleep (1) x٪ 2 def cube (n): for x in n: time.sleep (1) x٪ 3 n = [1،2،3 ، 4،5،6،7،8] s = time.time () sqr (n) cube (n) e = time.time () print (es)

انتاج:

16.042309284210205

ما سبق هو وقت الإخراج الذي يستغرقه تنفيذ البرنامج دون استخدام الخيوط. الآن دعنا نستخدم الخيوط ونرى ما يحدث لنفس البرنامج:

مثال:

استيراد مؤشرات الترابط من استيراد خيوط المعالجة * استيراد الوقت def sqr (n): لـ x in n: time.sleep (1) print ('المتبقي بعد القسمة على 2' ، x٪ 2) def cube (n): لـ x in n: time.sleep (1) print ('المتبقي بعد القسمة على 3' ، x٪ 3) n = [1،2،3،4،5،6،7،8] start = time.time () t1 = Thread ( الهدف = sqr ، args = (n ،)) t2 = الخيط (الهدف = المكعب ، args = (n ،)) t1.start () time.sleep (1) t2.start () t1.join () t2.join () end = time.time () print (end-start)

يوضح الناتج أعلاه بوضوح أن الوقت الذي يستغرقه استخدام الخيوط أقل بكثير مقارنة بالوقت الذي يستغرقه نفس البرنامج للتنفيذ دون استخدام مؤشرات الترابط.

آمل أن تكون واضحًا في المفاهيم التي تغطيها هذه المقالة المتعلقة بـ Multithreading في Python. تأكد من التدرب قدر الإمكان لأن هذا أحد أهم المفاهيم المستخدمة في البرمجة.

لديك سؤال لنا؟ يرجى ذكر ذلك في قسم التعليقات في مدونة 'Multithreading in Python' ونحن إرادة بالرد عليك في أقرب وقت ممكن.

للحصول على معرفة متعمقة حول Python مع تطبيقاتها المختلفة ، يمكنك التسجيل في البث المباشر مع دعم 24/7 والوصول مدى الحياة.