الفرق بين المراجعتين ل"Ruby/Thread"

من موسوعة حسوب
اذهب إلى التنقل اذهب إلى البحث
(أنشأ الصفحة ب'<noinclude>{{DISPLAYTITLE: صفحة الصنف <code>Thread</code> في روبي}}</noinclude> تصنيف: Ruby تصنيف: Ruby Threadالمهام الفرعي...')
 
ط (مراجعة وتدقيق.)
 
(4 مراجعات متوسطة بواسطة مستخدمين اثنين آخرين غير معروضة)
سطر 1: سطر 1:
−
<noinclude>{{DISPLAYTITLE: صفحة الصنف <code>Thread</code> في روبي}}</noinclude>
+
<noinclude>{{DISPLAYTITLE:الصنف <code>Thread</code> في روبي}}</noinclude>
 
[[تصنيف: Ruby]]
 
[[تصنيف: Ruby]]
−
[[تصنيف: Ruby Thread]]المهام الفرعية (Threads) هي الطريقة التي تقدم بها روبي البرمجة المتزامنة (programming model).
+
[[تصنيف: Ruby Class]]
 +
[[تصنيف: Ruby Thread]]
 +
المهام الفرعية (Threads، وتدعى "الخيوط" أيضًا) هي الطريقة التي تنفذ بها روبي البرمجة المتزامنة (concurrent programming).
  
−
البرامج التي تتطلب تنفيذ عدة مهام فرعية يمكنها استخدام الصنف <code>Thread</code>.
+
البرامج التي تتطلب تنفيذ عدة مهام فرعية يمكنها استخدام الصنف <code>Thread</code>. على سبيل المثال، يمكننا إنشاء مهمة فرعية جديدة منفصلة عن المهمة الرئيسية باستخدام التابع <code>[[Ruby/Thread/new|new]]</code>.<syntaxhighlight lang="ruby">thr = Thread.new { puts "Whats the big deal" }‎</syntaxhighlight>ثم يمكننا إيقاف تنفيذ المهمة الفرعية الرئيسية مؤقتًا إلى حين إنتهاء المهمة الفرعية خاصتنا باستخدام التابع <code>[[Ruby/Thread/join|join]]</code>:<syntaxhighlight lang="ruby">thr.join #=> "Whats the big deal"‎</syntaxhighlight>في حال عدم استدعاء التابع [[Ruby/Thread/join|<code>join</code>]] قبل انتهاء المهمة الرئيسية، فسيتم إنهاء جميع المهام الفرعية الأخرى، بما في ذلك المهمة الفرعية التي أنشأناها.
  
−
على سبيل المثال، يمكننا إنشاء مهمة فرعية جديدة منفصلة عن المهمة الرئيسية باستخدام <code>[[Ruby/Thread/new|::new]]</code>.
+
بدلاً من ذلك، يمكنك استخدام [[Ruby/Array|مصفوفة]] للتعامل مع عدة مهام فرعية في وقت واحد كما في المثال التالي:<syntaxhighlight lang="ruby">threads = []
−
<syntaxhighlight lang="ruby">thr = Thread.new { puts "Whats the big deal" }‎</syntaxhighlight>
 
−
ثم يمكننا إيقاف تنفيذ المهمة الفرعية الرئيسية مؤقتًا إلى حين إنهاء المهمة الفرعية خاصتنا باستخدام التابع <code>[[Ruby/Thread/join|join]]</code>:
 
−
<syntaxhighlight lang="ruby">thr.join #=> "Whats the big deal"‎</syntaxhighlight>
 
−
في حال عدم استدعاء التابع <code>thr.join</code> قبل انتهاء المهمة الرئيسية ، فسيتم إنهاء جميع المهام الفرعية الأخرى، بما في ذلك <code>thr</code>.
 
−
 
 
−
بدلاً من ذلك، يمكنك استخدام [[Ruby/Array|مصفوفة]] للتعامل مع عدة مهام فرعية في وقت واحد ، كما في المثال التالي:
 
−
<syntaxhighlight lang="ruby">threads = []
 
 
threads << Thread.new { puts "Whats the big deal" }
 
threads << Thread.new { puts "Whats the big deal" }
−
threads << Thread.new { 3.times { puts "Threads are fun!" } }‎</syntaxhighlight>
+
threads << Thread.new { 3.times { puts "Threads are fun!" } }‎</syntaxhighlight>بعد إنشاء عدد من المهام الفرعية، سننتظر إلى أن تنتهي جميعها بالتتابع.<syntaxhighlight lang="ruby">threads.each { |thr| thr.join }‎</syntaxhighlight>
−
بعد إنشاء عدد من المهام الفرعية، سننتظر أن تنتهي جميعها بالتتابع.
+
==تهيئة المهام الفرعية==
−
<syntaxhighlight lang="ruby">threads.each { |thr| thr.join }‎</syntaxhighlight>
+
لإنشاء مهام فرعية جديدة، توفر روبي عدة توابع لذلك هي: <code>[[Ruby/Thread/new|new]]</code> و <code>[[Ruby/Thread/start|start]]</code> و <code>[[Ruby/Thread/fork|fork]]</code>. يجب تمرير كتلة مع كل هذه التوابع، وإلا سيُطلق الاستثناء <code>[[Ruby/ThreadError|ThreadError]]</code>.
−
تهيئة المهام الفرعية <code>Thread</code>
 
−
<code>[[Ruby//class-Thread-label-Thread+initialization|¶]]</code> <code>[[Ruby//top|↑]]</code>
 
−
 
 
−
لإنشاء مهام فرعية جديدة، توفر روبي لذلك التوابع <code>[[Ruby/Thread/new|::new]]</code> و <code>[[Ruby/Thread/start|::start]]</code> و <code>[[Ruby/Thread/fork|::fork]]</code>. يجب تمرير كتلة مع كل هذه التوابع، وإلا سيُطلق استثناء <code>[[Ruby/ThreadError|ThreadError]]</code>.
 
−
 
 
−
عند انشاء أصناف فرعيى من <code>Thread</code>، فسيتم تجاهل التابع <code>initialize</code> الخاص بصنفك الفرعي من قبل التوابع <code>[[Ruby/Thread/start|::start]]</code> و <code>[[Ruby/Thread/fork|::fork]]</code>. لذلك تأكد من استدعاء المتغير super في التابع <code>initialize</code> خاصتك.
 
  
−
إنهاء الفرعية <code>Thread</code>
+
عند اشتقاق أصناف فرعية (subclasses) من <code>Thread</code>، فسيتم تجاهل التابع <code>initialize</code> الخاص بصنفك الفرعي من قبل التوابع <code>[[Ruby/Thread/start|start]]</code> و <code>[[Ruby/Thread/fork|fork]]</code>. لذلك تأكد من استدعاء المتغير <code>super</code> في التابع <code>initialize</code> خاصتك.
−
<code>[[Ruby//class-Thread-label-Thread+termination|]]</code> <code>[[Ruby//top|↑]]</code>
+
==إنهاء مهمة الفرعية==
−
 
+
توفر روبي مجموعة متنوعة من الطرق لإنهاء المهام الفرعية. ينهي (أو يقتل) التابع <code>[[Ruby/Thread/kill|kill]]</code> مثلًا المهمة الفرعية المعطاة:<syntaxhighlight lang="ruby">thr = Thread.new { ... }
−
لإنهاء المهام الفرعية، توفر روبي مجموعة متنوعة من الطرق للقيام بذلك.
+
Thread.kill(thr) # sends exit() to thr‎</syntaxhighlight>أو يمكنك استخدام تابع النسخة <code>[[Ruby/Thread/exit|exit]]</code>، أو أحد الأسماء البديلة له وهي <code>[[Ruby/Thread/kill|kill]]</code> و <code>[[Ruby/Thread/terminate|terminate]]</code>.<syntaxhighlight lang="ruby">thr.exit‎</syntaxhighlight>
−
 
+
==حالة مهمة الفرعية==
−
يقوم التابع <code>[[Ruby/Thread/kill|::kill]]</code> بإنهاء المهمة الفرعية المعطاة:
+
توفر روبي عددًا من من توابع النسخة (instance methods) لاستخلاص حالة مهمة فرعية معينة. للحصول على [[Ruby/String|سلسلة نصية]] تحتوي حالة المهمة الفرعية الحالية، استخدم التابع <code>[[Ruby/Thread/status|status]]</code>:<syntaxhighlight lang="ruby">thr = Thread.new { sleep }
−
<syntaxhighlight lang="ruby">thr = Thread.new { ... }
 
−
Thread.kill(thr) # sends exit() to thr‎</syntaxhighlight>
 
−
بدلاً من ذلك، يمكنك استخدام تابع النسخة <code>[[Ruby/Thread/exit|exit]]</code> أو أيًّا من مرادفيه <code>[[Ruby/Thread/kill|kill]]</code> و <code>[[Ruby/Thread/terminate|terminate]]</code>.
 
−
<syntaxhighlight lang="ruby">thr.exit‎</syntaxhighlight>
 
−
حالة المهمة الفرعية <code>Thread</code>
 
−
<code>[[Ruby//class-Thread-label-Thread+status|¶]]</code> <code>[[Ruby//top|↑]]</code>
 
−
 
 
−
توفر روبي عددا من من توابع النسخ (instance methods) لاستخلاص حالة مهمة فرعية معينة. للحصول على [[Ruby/String|سلسلة نصية]] تحتوي حالة المهمة الفرعية الحالية استخدم التابع <code>[[Ruby/Thread/status|status]]</code>
 
−
<syntaxhighlight lang="ruby">thr = Thread.new { sleep }
 
 
thr.status # => "sleep"
 
thr.status # => "sleep"
 
thr.exit
 
thr.exit
−
thr.status # => false‎</syntaxhighlight>
+
thr.status # => false‎</syntaxhighlight>يمكنك أيضًا استخدام التابع <code>[[Ruby/Thread/alive-3F|alive?‎]]</code> للتحقق مما إذا كانت المهمة الفرعية قيد التشغيل أو نائمة، أو التابع <code>[[Ruby/Thread/stop-3F|stop?‎]]</code> للتحقق مما إذا كانت المهمة الفرعية ميتة أو نائمة.
−
يمكنك أيضًا استخدام <code>[[Ruby/Thread/alive-3F|alive?]]</code> للتحقق مما إذا كانت المهمة الفرعية قيد التشغيل أو نائمة، أو التابع <code>[[Ruby/Thread/stop-3F|stop?]]</code> للتحقق مما إذا كانت المهمة الفرعية ميتة أو نائمة.
+
==متغيرات ونطاق مهمة الفرعية==
−
 
+
نظرًا لكون المهام الفرعية تُنشأ بواسطة الكتل، فستُطبَّق القواعد نفسها على كتل روبي الأخرى فيما يتعلق بنطاق (scope) المتغيرات. المتغيرات المحلية التي تم إنشاؤها داخل هذه الكتلة لا يمكن الوصول إليها إلا من داخل هذه المهمة الفرعية.
−
متغيرات ومدى المهمة الفرعية <code>Thread</code>
+
==الألياف المحلية مقابل الخيوط المحلية==
−
<code>[[Ruby//class-Thread-label-Thread+variables+and+scope|¶]]</code> <code>[[Ruby//top|↑]]</code>
+
يحتوي كل [[Ruby/Fiber|ليف]] (fiber) على نطاق خاص به لتخزين العناصر المعيّنة من المعامل <code>[[Ruby/Thread/index operator|[]]]</code>. عندما تعيِّن [[Ruby/Fiber|ليفًا]] محليًّا (fiber-local)، فلن يمكن الوصول إليه إلا من داخل ذلك [[Ruby/Fiber|الليف]]. المثال التالي يوضح ذلك:<syntaxhighlight lang="ruby">Thread.new {
−
 
 
−
نظرًا لكون المهام الفرعية تُنشأ بواسطة الكتل، تنطبق القواعد نفسها على كتل روبي الأخرى فيما يتعلقق بمدى المتغيرات. المتغيرات المحلية التي تم إنشاؤها داخل هذه الكتلة لا يمكن الوصول إليها إلا من داخل هذه المهمة الفرعية.
 
−
 
 
−
تخزين الألياف المحلي مقابل تخزين المهام الفرعية المحلي
 
−
<code>[[Ruby//class-Thread-label-Fiber-local+vs.+Thread-local|¶]]</code> <code>[[Ruby//top|↑]]</code>
 
−
 
 
−
يحتوي كل [[Ruby/Fiber|الليف]] (fiber) على نطاق خاص به لتخزين <code>[[Ruby/Thread/5B-5D|#[]]]</code>. عندما تقوم بتعيين نطاق تخزين جديد مخصوص ب[[Ruby/Fiber|الليف]] (fiber-local)، فلن يمكن الوصول إليه إلا من داخل هذا [[Ruby/Fiber|الليف]] (<code>[[Ruby/Fiber|Fiber]]</code>). المثال التالي يوضح ذلك:
 
−
<syntaxhighlight lang="ruby">Thread.new {
 
 
   Thread.current[:foo] = "bar"
 
   Thread.current[:foo] = "bar"
 
   Fiber.new {
 
   Fiber.new {
 
     p Thread.current[:foo] # => nil
 
     p Thread.current[:foo] # => nil
 
   }.resume
 
   }.resume
−
}.join‎</syntaxhighlight>
+
}.join‎</syntaxhighlight>يستخدم هذا المثال معامل الفهرسة [[Ruby/Thread/index operator|<code>[]</code>]] لأجل الاستخلاص، ويستخدم معامل التعيين [[Ruby/Thread/index operator-3D|<code>=[]</code>]] لأجل تعيين [[Ruby/Fiber|ليف]] محلي (fiber-locals)؛ يمكنك أيضًا استخدام التابع <code>[[Ruby/Thread/keys|keys]]</code> لإنشاء قائمة بالألياف المحلية لمهمة فرعية معينة، أو التابع <code>[[Ruby/Thread/key-3F|key?‎]]</code> للتحقق من وجود ألياف محلية.
−
يستخدم هذا المثال <code>[[Ruby/Thread/5B-5D|[]]]</code> لأجل الاستخلاص، ويستخد <code>[[Ruby/Thread/5B-5D-3D|[]=]]</code> لأجل تعيين المتغيرات المخصوصة ب[[Ruby/Fiber|الليف]] (fiber-locals)، يمكنك أيضاً استخدام <code>[[Ruby/Thread/keys|keys]]</code> لسرد المتغيرات المخصوصة ب[[Ruby/Fiber|الليف]] لمهمة فرعية معينة، والتابع <code>[[Ruby/Thread/key-3F|key?]]</code> للتحقق من وجود متغيرات مخصوصة ب[[Ruby/Fiber|الليف]].
 
  
−
يمكن الوصول إلى المتغيرات المخصوصة بالمهمة الفرعية (thread-locals) من كامل مدى تلك المهمة. في المثال التالي:
+
يمكن الوصول إلى المتغيرات المحلية في المهمة الفرعية (thread-locals) من أي مكان في نطاق تلك المهمة. إليك المثال التالي:<syntaxhighlight lang="ruby">Thread.new{
−
<syntaxhighlight lang="ruby">Thread.new{
 
 
   Thread.current.thread_variable_set(:foo, 1)
 
   Thread.current.thread_variable_set(:foo, 1)
 
   p Thread.current.thread_variable_get(:foo) # => 1
 
   p Thread.current.thread_variable_get(:foo) # => 1
سطر 70: سطر 40:
 
   }.resume
 
   }.resume
 
   p Thread.current.thread_variable_get(:foo)  # => 2
 
   p Thread.current.thread_variable_get(:foo)  # => 2
−
}.join‎</syntaxhighlight>
+
}.join‎</syntaxhighlight>يمكنك أن ترى أن المتغير ‎<code>:foo</code> محلي المهمة الفرعية قد وصل إلى نطاق الل[[Ruby/Fiber|يف]]، ثم تم تغييره إلى القيمة <code>2</code> في نهاية المهمة الفرعية.
−
يمكنك أن ترى أن المتغير <code>:foo</code> المخصوص بالمهمة الفرعية قد وصل إلى نطاق الل[[Ruby/Fiber|ليف]]، ثم تم تغييره إلى القيمة <code>2</code> في نهاية المهمة الفرعية.
 
  
−
هذا المثال يستخدم التابع <code>[[Ruby/Thread/thread_variable_set|thread_variable_set]]</code> لإنشاء مهمة فرعية جديدة، ويستخدم <code>[[Ruby/Thread/thread_variable_get|thread_variable_get]]</code> للرجوع إليها.
+
هذا المثال يستخدم التابع <code>[[Ruby/Thread/thread variable set|thread_variable_set]]</code> لإنشاء مهمة فرعية جديدة، ويستخدم <code>[[Ruby/Thread/thread variable get|thread_variable_get]]</code> للرجوع إليها.
  
−
هناك أيضًا التابع <code>[[Ruby/Thread/thread_variables|thread_variables]]</code> لسرد جميع المتغيرات المحلية في المهمة الفرعية (thread-locals)، والتابع <code>[[Ruby/Thread/thread_variable-3F|thread_variable?]]</code> للتحقق من وجود متغير محلي محدد في المهمة الفرعية.
+
يمكن أيضًا استخدام التابع <code>[[Ruby/Thread/thread variables|thread_variables]]</code> لإنشاء قائمة بجميع المتغيرات المحلية في مهمة فرعية (thread-locals)، والتابع <code>[[Ruby/Thread/thread variable-3F|thread_variable?‎]]</code> للتحقق من وجود متغير محلي معين في مهمة فرعية.
 +
==معالجة الاستثناءات==
 +
يمكن لأي مهمة فرعية إطلاق [[Ruby/Exception|استثناء]] باستخدام تابع النسخة <code>[[Ruby/Thread/raise|raise]]</code>، والذي يعمل بطريقة مشابهة للتابع <code>[[Ruby/Kernel/raise|Kernel.raise]]</code>.
  
−
معالجة الاستثناء<code>[[Ruby/Exception|Exception]]</code>  
+
من الجدير بالذكر أنّ الاستثناءات التي تُطلق من أي مهمة الفرعية، باستثناء الرئيسية (main thread)، التي تعتمد على <code>[[Ruby/Thread/abort on exception|abort_on_exception]]</code>. قيمة هذا الخيار الافتراضية هي <code>false</code>، مما يعني أن أي استثناء غير مُعالَج سيؤدي إلى إنهاء المهمة الفرعية بصمت عند الانتظار سواءً من <code>[[Ruby/Thread/join|join]]</code> أو من <code>[[Ruby/Thread/value|value]]</code>. يمكنك تغيير هذا الإعداد الافتراضي عبر استدعاء <code>[[Ruby/Thread/abort on exception-3D|abort_on_exception=]] true</code>، أو من خلال إعطاء التابع <code>[[Ruby/Thread/DEBUG|DEBUG]]</code> القيمة <code>true</code>.
−
<code>[[Ruby//class-Thread-label-Exception+handling|]]</code> <code>[[Ruby//top|↑]]</code>
 
  
−
يمكن لأي مهمة فرعية إطلاق استثناء باستخدام تابع النسخة <code>[[Ruby/Thread/raise|raise]]</code>، والذي يعمل بطريقة مشابهة للتابع <code>[[Ruby/Kernel/raise|Kernel#raise]]</code>.
+
مع إضافة تابع الصنف <code>[[Ruby/Thread/handle interrupt|handle_interrupt]]</code>، يمكنك الآن معالجة الاستثناءات بشكل غير متزامن بالمهام الفرعية.
 +
==الجدولة (Scheduling)==
 +
توفر روبي عدة وسائل لجدولة المهام الفرعية في البرنامج. الطريقة الأولى هي باستخدام تابع الصنف <code>[[Ruby/Thread/stop|stop]]</code>، لوضع المهمة الفرعية الحالية في حالة نوم، وجدولة عملية تنفيذ مهمة فرعية أخرى.
  
−
من الجدير بالذكر أنّ الاستثناءات التي تُطلق الذي يحدث من أي مهمة الفرعية، باستثناء الرئيسية، ستعتمد على <code>[[Ruby/Thread/abort_on_exception|abort_on_exception]]</code>. قيمة هذا الخيار الافتراضية هي <code>false</code>، مما يعني أن أي استثناء غير مُعالَج سيؤدي إلى إنهاء المهمة الفرعية بصمت عند الانتظار سواء من <code>[[Ruby/Thread/join|join]]</code> أو من <code>[[Ruby/Thread/value|value]]</code>. يمكنك تغيير هذا الإعداد الافتراضي من خلال <code>[[Ruby/Thread/abort_on_exception-3D|abort_on_exception=]]</code><code>true</code> ، أو من خلال إعطاء DEBUG القيمة <code>true</code>.
+
بمجرد أن تصبح المهمة الفرعية في حالة نوم، يمكنك استخدام التابع <code>[[Ruby/Thread/wakeup|wakeup]]</code> لجعلها متاحة للجدولة.
  
−
مع إضافة تابع الصنف <code>[[Ruby/Thread/handle_interrupt|::handle_interrupt]]</code> ، يمكنك الآن معالجة الاستثناءات بشكل غير متزامن بالمهام الفرعية.
+
يمكنك أيضًا استخدام التابع <code>[[Ruby/Thread/pass|pass]]</code>، والذي يحاول تمرير التنفيذ إلى مهمة فرعية أخرى؛ مسألة استبدال المهمة الفرعية قيد التشغيل تتعلق بنظام التشغيل المستخدم. وينطبق الأمر ذاته على التابع <code>[[Ruby/Thread/priority|priority]]</code>، والذي يتيح لك الطلب من مُجدوِل المهام الفرعية (thread scheduler) إعطاء الأسبقية  لمهام فرعية معينة عند التنفيذ. يعتمد هذا التابع أيضًا على نظام التشغيل، وقد يُتجاهَل في بعض الأنظمة.
−
 
+
==توابع الصنف العامة==
−
الجدولة (Scheduling)
+
===[[Ruby/Thread/DEBUG|<code>DEBUG</code>]]===
−
<code>[[Ruby//class-Thread-label-Scheduling|]]</code> <code>[[Ruby//top|↑]]</code>
+
يُعيد مستوى التصحيح في المهمة الفرعية (thread debug level).
−
 
+
===[[Ruby/Thread/DEBUG-3D|<code>DEBUG=‎</code>]]===
−
توفر روبي عدة وسائل لجدولة المهام الفرعية في البرنامج.
+
يعيّن عند استدعائه بالشكل <code>DEBUG = num</code> قيمة مستوى تصحيح <nowiki/>المهمة الفرعية (thread debug level) إلى القيمة <code>num</code>.
 +
===[[Ruby/Thread/abort on exception|<code>abort_on_exception</code>]]===
 +
يُعيد حالة الشرط العام "المقاطعة عند حدوث استثناء؟" (abort on exception). 
 +
===[[Ruby/Thread/abort on exception-3D|<code>abort_on_exception=‎</code>]]===
 +
يضبط عند استدعائه بالشكل <code>abort_on_exception= boolean</code> حالة الشرط العام "المقاطعة عند حدوث استثناء؟" (abort on exception) إلى القيمة المنطقية <code>boolean</code>.
 +
===[[Ruby/Thread/current|<code>current</code>]]===
 +
يُعيد المهمة الفرعية المُنفّذة حاليًّا.
 +
===[[Ruby/Thread/exclusive|<code>exclusive</code>]]===
 +
يغلف الكتلة المعطاة في دالة الآلة الافتراضية العامة (VM-global)‏<code>[[Ruby/Mutex/synchronize|Mutex.synchronize]]</code>، ثم يعيد قيمة الكتلة.
 +
===[[Ruby/Thread/exit|<code>exit</code>]]===
 +
ينهي المهمة الفرعية قيد التشغيل، ويُجدول مهمة فرعية أخرى ليتم تشغيلها.
 +
===[[Ruby/Thread/fork|<code>fork</code>]]===
 +
ينشئ عملية فرعية جديدة بشكل مكافئ للتابع new.
 +
===[[Ruby/Thread/handle interrupt|<code>handle_interrupt</code>]]===
 +
يغير توقيت المقاطعة غير المتزامنة (asynchronous interrupt timing).
 +
===[[Ruby/Thread/kill|<code>kill</code>]]===
 +
ينهي المهمة الفرعية المعطاة.
 +
===[[Ruby/Thread/list|<code>list</code>]]===
 +
يُعيد [[Ruby/Array|مصفوفة]] من المهام الفرعية العاملة أو المتوقفة.
 +
===[[Ruby/Thread/main|<code>main</code>]]===
 +
يُعيد المهمة الفرعية الرئيسية.
 +
===[[Ruby/Thread/new|<code>new</code>]]===
 +
ينشئ مهمة فرعية جديدة تقوم بتنفيذ الكتلة المعطاة.
 +
===[[Ruby/Thread/pass|<code>pass</code>]]===
 +
يعطي إلى مُجدوِل المهمة الفرعية تلميحًا لتمرير التنفيذ إلى مهمة فرعية أخرى.
 +
===[[Ruby/Thread/pending interrupt-3F|<code>pending_interrupt?‎</code>]]===
 +
يتحقق مما إذا كان طابور الانتظار غير المتزامن فارغًا أم لا.
 +
===[[Ruby/Thread/report on exception|<code>report_on_exception</code>]]===
 +
يعيد حالة "التبليغ عند الاستثناء" (report on exception). 
 +
===[[Ruby/Thread/report on exception-3D|<code>report_on_exception=‎</code>]]===
 +
يضبط عند استدعائه بالشكل <code>report_on_exception= boolean‎</code> حالة "التبليغ عند الاستثناء" (report on exception).
 +
===[[Ruby/Thread/start|<code>start</code>]]===
 +
يشبه التابع <code>[[Ruby/Thread/new|new]]</code> بشكل أساسي إلا أنه عند اشتقاق صنف فرعي (subclassed) من <code>Thread</code>، فإنَّ استدعاء <code>start</code> في ذلك الصنف الفرعي لن يستدعي تابع الصنف الفرعي<code>initialize</code>.
 +
===[[Ruby/Thread/stop|<code>stop</code>]]===
 +
يوقف تنفيذ المهمة الفرعية الحالية، ويضعها في حالة "نوم" (sleep)، ويُجدوٍل (schedules) تنفيذ مهمة فرعية أخرى.
  
−
الطريقة الأولى هي باستخدام تابع الصنف <code>[[Ruby/Thread/stop|::stop]]</code>، لوضع المهمة الفرعية الحالية في حالة نوم، وجدولة عملية تنفيذ مهمة فرعية أخرى.
+
== تزوابع النسخة العامة (Public Instance Methods) ==
  
−
بمجرد أن تصبح المهمة الفرعية في حالة نوم، يمكنك استخدام تابع النسخ <code>[[Ruby/Thread/wakeup|wakeup]]</code> لجعل المهمة الفرعية متاحة للجدولة.
+
===<code rel="mw:WikiLink" title="Ruby/Thread/index operator" href="Ruby/Thread/index operator">[[Ruby/Thread/index operator|[]]]</code>===
 +
يُعيد قيمة متغير محلي [[Ruby/Fiber|الليف]] fiber) local variable، أو [[Ruby/Fiber|الليف]] الأصلي للمهمة الفرعية الحالية إن لم يكن المتغير موجودًا داخل [[Ruby/Fiber|ليف]]) باستخدام إما رمز أو [[Ruby/String|سلسلة نصية]].
 +
===[[Ruby/Thread/index operator-3D|<code>=[]</code>]]===
 +
يعيّن عندما يُستدعى بالشكل <code>thr[sym] = obj</code> قيمة المتغير <code>sym</code> محلي [[Ruby/Fiber|الليف]] (fiber-local variable)، باستخدام إما الرمز أو [[Ruby/String|السلسلة النصية]] <code>obj</code> أو ينشئها.
 +
===[[Ruby/Thread/abort on exception|<code>abort_on_exception</code>]]===
 +
يُعيد حالة الشرط المحلي (thread-local‏) "المقاطعة عند حدوث استثناء؟" (abort on exception) في المهمة الفرعية التي استُدعي معها.
 +
===[[Ruby/Thread/abort on exception-3D|<code>abort_on_exception=‎</code>]]===
 +
يضبط عند استدعائه بالشكل <code>abort_on_exception= boolean</code> حالة الشرط المحلي "المقاطعة عند حدوث استثناء؟" (abort on exception) إلى القيمة المنطقية <code>boolean</code>.
 +
===[[Ruby/Thread/add trace func|<code>add_trace_func</code>]]===
 +
يضيف عملية (كائنًا من النوع <code>[[Ruby/Proc|Proc]]</code>) كمعالج للتعقب (tracing) إلى المهمة الفرعية التي استدعيت معه.
 +
===[[Ruby/Thread/alive-3F|<code>alive?‎</code>]]===
 +
يتحقق إن كانت المهمة الفرعية التي استُدعي معها قيد التشغيل أو نائمة.
 +
===[[Ruby/Thread/backtrace|<code>backtrace</code>]]===
 +
يُعيد التعقب (backtrace) الحالي للمهمة فرعية التي استدعي معها.
 +
===[[Ruby/Thread/backtrace locations|<code>backtrace_locations</code>]]===
 +
يُعيد مكدس التنفيذ (execution stack) الخاص بالمهمة الفرعية على شكل <nowiki/>[[Ruby/Array|مصفوفة]] تحتوي على كائنات التعقب (backtrace location objects).
  
−
يمكنك أيضًا استخدام التابع <code>[[Ruby/Thread/pass|::pass]]</code>، والذي يحاول تمرير التنفيذ إلى مهمة فرعية أخرى، مسألة استبدال المهمة الفرعية قيد التشغيل تتعلق بنظام التشغيل المستخدم. وينطبق الأمر ذاته على <code>[[Ruby/Thread/priority|priority]]</code>، والذي يتيح لك الطلب من مُجدوِل المهام الفرعية (thread scheduler) المهام الفرعية التي تريدها أن تأخذ الأسبقية عند التنفيذ. يعتمد هذا التابع أيضًا على نظام التشغيل، وقد يُتجاهل في بعض الأنظمة.
+
=== <code>[[Ruby/Thread/fetch|fetch]]</code> ===
−
==توابع الصنف العامة (Public Class Methods)==
+
(لم يوثَّق بعد.)
−
===[[Ruby/Thread/DEBUG | التابع DEBUG]]===
 
−
يُعيد التابع <code>DEBUG</code> مستوى التصحيح في [[Ruby/Thread|المهمة الفرعية]] (thread debug level).  متوفرة فقط في حالة تصريفها (compiled) مع الخيار THREAD_DEBUG = -1.
 
−
===[[Ruby/Thread/DEBUG-3D | التابع DEBUG=]]===
 
−
يعيّن التابع <code>DEBUG=</code> مستوى تصحيح [[Ruby/Thread|المهمة الفرعية]] (thread debug level).  متوفرة فقط في حالة تصريفها (compiled) مع الخيار THREAD_DEBUG = -1.
 
−
===[[Ruby/Thread/abort_on_exception | التابع abort_on_exception]]===
 
−
يُعيد التابع <code>abort_on_exception</code> حالة الشرط العام "abort on exception".
 
−
===[[Ruby/Thread/abort_on_exception-3D | التابع abort_on_exception=]]===
 
−
عند إعطائه القيمة <code>true</code>، فأي [[Ruby/Thread|مهمة فرعية]] توقف بواسطة استثناء، سيتم إطلاق ذلك الاستثناء مجددا في [[Ruby/Thread|المهمة الفرعية]] الرئيسية (main thread). يُعيد التابع <code>abort_on_exception=</code> الحالة الجديدة.
 
−
===[[Ruby/Thread/current | التابع current]]===
 
−
يُعيد التابع <code>current</code> [[Ruby/Thread|المهمة الفرعية]] المُنفّذة حاليا.
 
−
===[[Ruby/Thread/exclusive | التابع exclusive]]===
 
−
يغلف التابع <code>exclusive</code> الكتلة المعطاة في دالة الآلة الافتراضية العامة (VM-global) <code>[[Ruby/Mutex/synchronize|Mutex#synchronize]]</code> ، ثم يعيد قيمة الكتلة. [[Ruby/Thread|المهمة الفرعية]] التي تُنفّذ داخل القسم الحصري (exclusive section) لن تعطل إلا [[Ruby/Thread|المهمة الفرعية]] الأخرى التي تستخدم أيضًا آلالية <code>[[Ruby/Thread/exclusive|::exclusive]]</code>.
 
−
===[[Ruby/Thread/exit | التابع exit]]===
 
−
ينهي التابع <code>exit</code> [[Ruby/Thread|المهمة الفرعية]] قيد التشغيل، ويُجدول [[Ruby/Thread|مهمة فرعية]] أخرى ليتم تشغيلها.
 
−
===[[Ruby/Thread/fork | التابع fork]]===
 
−
أساسا، التابع التابع <code>fork</code> مكافئ للتابع new. ومع ذلك ، في حال اشتقاق صنف فرعي من <code>[[Ruby/Thread/new|::new]]</code>، فإن استدعاء <code>[[Ruby/Thread|Thread]]</code> في ذلك الصنف الفرعي لن يستدعي تابع الصنف الفرعي <code>[[Ruby/Thread/start|start]]</code>.
 
−
===[[Ruby/Thread/handle_interrupt | التابع handle_interrupt]]===
 
−
يغير التابع <code>handle_interrupt</code> توقيت المقاطعة غير المتزامنة (asynchronous interrupt timing).
 
−
===[[Ruby/Thread/kill | التابع kill]]===
 
−
بقوم التابع <code>kill</code> بإنهاء <code>thread</code> المعطى (انظر فقرة البنية العامة)، راجع أيضًا صفحة <code>[[Ruby/Thread/exit|::exit]]</code>.
 
−
===[[Ruby/Thread/list | التابع list]]===
 
−
يُعيد التابع <code>list</code> [[Ruby/Array|مصفوفة]] من [[Ruby/Thread|المهمة الفرعية]] <code>[[Ruby/Thread|Thread]]</code> لكافة [[Ruby/Thread|المهمة الفرعية]] المشتغلة أو المتوقفة.
 
−
===[[Ruby/Thread/main | التابع main]]===
 
−
يُعيد التابع <code>main</code> [[Ruby/Thread|المهمة الفرعية]] الرئيسية.
 
−
===[[Ruby/Thread/new | التابع new]]===
 
−
ينشئ التابع <code>new</code> [[Ruby/Thread|مهمة فرعية]] جديدة تقوم بتنفيذ الكتلة المعطاة.
 
−
===[[Ruby/Thread/pass | التابع pass]]===
 
−
يعطي التابع <code>pass</code> إلى مُجدوِل [[Ruby/Thread|المهمة الفرعية]] تلميحًا لتمرير التنفيذ إلى [[Ruby/Thread|مهمة فرعية]] أخرى. مسألة تبديل [[Ruby/Thread|المهمة الفرعية]] قيد التشغيل من عدمها تعتمد على نظام التشغيل والمعالج المستخدمين.
 
−
===[[Ruby/Thread/pending_interrupt-3F | التابع pending_interrupt?‎]]===
 
−
يتحقق التابع <code>pending_interrupt?‎</code> مما إذا كان طابور الانتظار غير المتزامن فارغًا أم لا.
 
−
===[[Ruby/Thread/report_on_exception | التابع report_on_exception]]===
 
−
يعيد التابع <code>report_on_exception</code> حالة report on exception".
 
−
===[[Ruby/Thread/report_on_exception-3D | التابع report_on_exception=]]===
 
−
يُعيد التابع <code>report_on_exception=</code> الحالة الجديدة. عند إعطائه القيمة <code>true</code>، سترث كل [[Ruby/Thread|المهمة الفرعية]] التي تم إنشاؤها لاحقا الشرط (condition ) وستبعث رسالة على المجرى $ stderr إذا أنهى استثناء ما [[Ruby/Thread|المهمة الفرعية]]:
 
−
===[[Ruby/Thread/start | التابع start]]===
 
−
أساسا يشبه التابع <code>start</code> التابع <code>[[Ruby/Thread/new|::new]]</code>. إلا أنه عند اشتقاق صنف فرعي (subclassed) من <code>[[Ruby/Thread|Thread]]</code>، فإن استدعاء <code>start</code> في ذلك الصنف الفرعي لن يستدعي تابع الصنف الفرعي <code>initialize</code>.
 
−
===[[Ruby/Thread/stop | التابع stop]]===
 
−
يوقف التابع <code>stop</code> تنفيذ [[Ruby/Thread|المهمة الفرعية]] الحالية، ويضعها في حالة "نوم" (sleep)، ويُجدوٍل (schedules) تنفيذ [[Ruby/Thread|مهمة فرعية]] أخرى.
 
−
===[[Ruby/Thread/index_operator | التابع []]]===
 
−
مرجع الخصائص (Attribute Reference) - يُعيد قيمة متغير [[Ruby/Fiber|الليف]] المحلي fiber-local variable ([[Ruby/Fiber|الليف]] الأصلي لل[[Ruby/Thread|مهمة فرعية]] الحالية إن لم يكن موجودًا داخل [[Ruby/Fiber|ليف]] <code>[[Ruby/Fiber|Fiber]]</code>) ، باستخدام إما رمز أو اسم [[Ruby/String|سلسلة نصية]]. إن لم يكن المتغير المعطى (انظر فقرة البنية العامة) غير موجود، فستعاد <code>nil</code>.
 
−
===[[Ruby/Thread/index_operator-3D | التابع []=]]===
 
−
معامل تعيين الخاصيات (Attribute Assignment) - يعيّن أو ينشئ قيمة متغير محلي [[Ruby/Fiber|الليف]]، باستخدام إما رمز أو [[Ruby/String|سلسلة نصية]].
 
−
===[[Ruby/Thread/abort_on_exception | التابع abort_on_exception]]===
 
−
يُعيد التابع <code>abort_on_exception</code> حالة الشرط "abort on exception".
 
−
===[[Ruby/Thread/abort_on_exception-3D | التابع abort_on_exception=]]===
 
−
عند إعطائه القيمة <code>true</code>، إذا تم إيقاف أي [[Ruby/Thread|مهمة فرعية]] بواسطة استثناء، فسيطلق ذلك الاستثناء مجددا في [[Ruby/Thread|المهمة الفرعية]] الرئيسية. يُعيد الحالة الجديدة.
 
−
===[[Ruby/Thread/add_trace_func | التابع add_trace_func]]===
 
−
يضيف التابع <code>add_trace_func</code> الوسيط المعطى <code>proc</code> (انظر فقرة البنية العامة) كمعالج للتعقب (tracing).
 
−
===[[Ruby/Thread/alive-3F | التابع alive?‎]]===
 
−
يُعيد التابع <code>alive?‎</code> القيمة <code>true</code> إن كانت [[Ruby/Thread|المهمة الفرعية]] التي استُدعي معها <code>thr</code> قيد التشغيل أو نائمة.
 
−
===[[Ruby/Thread/backtrace | التابع backtrace]]===
 
−
يُعيد التابع <code>backtrace</code> التِّعقاب (backtrace) الحالي لل[[Ruby/Thread|مهمة فرعية]].
 
−
===[[Ruby/Thread/backtrace_locations | التابع backtrace_locations]]===
 
−
يُعيد التابع <code>backtrace_locations</code> مكدس التنفيذ (execution stack) الخاص ب[[Ruby/Thread|المهمة الفرعية]] — [[Ruby/Array|مصفوفة]] تحتوي على كائنات تعقب موقع (backtrace location objects).
 
−
===[[Ruby/Thread/exit | التابع exit]]===
 
−
ينهي التابع <code>exit</code> [[Ruby/Thread|المهمة الفرعية]] قيد التشغيل حاليًا، ويُجدوِل (schedules) [[Ruby/Thread|مهمة فرعية]] أخرى ليتم تشغيلها.
 
−
===[[Ruby/Thread/fetch | التابع fetch]]===
 
  
−
===[[Ruby/Thread/group | التابع group]]===
+
===[[Ruby/Thread/exit|<code>exit</code>]]===
−
يُعيد التابع <code>group</code> كائنا من النوع <code>[[Ruby/ThreadGroup|ThreadGroup]]</code>، والذي يحتوي [[Ruby/Thread|المهمة الفرعية]] المعطاة، أو يُعيد <code>nil</code> إذا لم يكن <code>thr</code> عضوًا في أي مجموعة.
+
ينهي المهمة الفرعية قيد التشغيل حاليًا، ويُجدوِل (schedules) مهمة فرعية أخرى ليتم تشغيلها.
−
===[[Ruby/Thread/inspect | التابع inspect]]===
+
===[[Ruby/Thread/group|<code>group</code>]]===
 +
يُعيد مجموعة الخيوط <code>[[Ruby/ThreadGroup|ThreadGroup]]</code> التي تحتوي على المهمة الفرعية المعطاة، أو يُعيد <code>nil</code> إذا لم تكن المهمة الفرعية عضوًا في أي مجموعة.
 +
===[[Ruby/Thread/inspect|<code>inspect</code>]]===
 +
يعيد اسم ورقم تعريف وحالة المهمة الفرعية على هيئة سلسلة نصية.
  
−
===[[Ruby/Thread/join | التابع join]]===
+
===[[Ruby/Thread/join|<code>join</code>]]===
−
عند استدعاء التابع <code>join</code>، فسيتوقف تنفيذ [[Ruby/Thread|المهمة الفرعية]] المُستدعية (calling thread)، وسيقوم بتنفيذ [[Ruby/Thread|المهمة الفرعية]] التي استُدعي معها <code>thr</code>.
+
يوقف عند استدعائه تنفيذ المهمة الفرعية المُستدعيَة (calling thread)، وبدء تنفيذ المهمة الفرعية التي استُدعي معها.
−
===[[Ruby/Thread/key-3F | التابع key?‎]]===
+
===[[Ruby/Thread/key-3F|<code>key?‎</code>]]===
−
يُعيد التابع <code>key?‎</code> القيمة <code>true</code> إن كانت [[Ruby/String|السلسلة النصية]] أو الرمز المعطى (انظر فقرة البنية العامة) موجودة على هيئة متغير محلي [[Ruby/Fiber|الليف]].
+
يتحقق إن كانت <nowiki/>[[Ruby/String|السلسلة النصية]] أو الرمز المعطى موجود على هيئة متغير محلي <nowiki/>[[Ruby/Fiber|الليف]](fiber-local variable).
−
===[[Ruby/Thread/keys | التابع keys]]===
+
===[[Ruby/Thread/keys|<code>keys</code>]]===
−
يُعيد التابع <code>keys</code> [[Ruby/Array|مصفوفة]] من أسماء المتغيرات محلية [[Ruby/Fiber|الليف]] (على هيئة رموز).
+
يُعيد [[Ruby/Array|مصفوفة]] من أسماء المتغيرات محلية [[Ruby/Fiber|الليف]] (على هيئة رموز).
−
===[[Ruby/Thread/kill | التابع kill]]===
+
===[[Ruby/Thread/kill|<code>kill</code>]]===
−
يؤدي التابع <code>kill</code> إلى إنهاء <code>thread</code> المعطى (انظر فقرة البنية العامة)، راجع أيضًا صفحة <code>[[Ruby/Thread/exit|::exit]]</code>.
+
ينهي المهمة الفرعية التي استُدعي معها، ثم يجدول مهمة فرعية أخرى لتنفيذها.
−
===[[Ruby/Thread/name | التابع name]]===
+
===[[Ruby/Thread/name|<code>name</code>]]===
−
يعيد التابع <code>name</code> اسم [[Ruby/Thread|المهمة الفرعية]].
+
يعيد اسم المهمة الفرعية.
−
===[[Ruby/Thread/name-3D | التابع name=]]===
+
===[[Ruby/Thread/name-3D|<code>name=‎</code>]]===
−
يعين التابع <code>name=</code> اسم معين لل[[Ruby/Thread|مهمة فرعية]] لروبي. في بعض أنظمة التشغيل، قد يتم تعيين الاسم لـ pthread و/أو لـ kernel.
+
يعين اسم المهمة الفرعية التي استدعيت معه إلى الاسم المُمرَّر إليه.
−
===[[Ruby/Thread/pending_interrupt-3F | التابع pending_interrupt?‎]]===
+
===[[Ruby/Thread/pending interrupt-3F|<code>pending_interrupt?‎</code>]]===
 
يتحقق مما إذا كان طابور الانتظار غير المتزامن فارغًا أم لا.
 
يتحقق مما إذا كان طابور الانتظار غير المتزامن فارغًا أم لا.
−
===[[Ruby/Thread/priority | التابع priority]]===
+
===[[Ruby/Thread/priority|<code>priority</code>]]===
−
يُعيد التابع <code>priority</code> أولوية [[Ruby/Thread|المهمة الفرعية]] <code>thr</code>. تورث القيمة الافتراضية من [[Ruby/Thread|المهمة الفرعية]] الحالي التي تنشئ [[Ruby/Thread|المهمة الفرعية]] الجديدة، أو صفر ل[[Ruby/Thread|مهمة فرعية]] الرئيسية الابتدائية؛ سيتم تشغيل [[Ruby/Thread|المهمة الفرعية]] ذات الأولوية العالية بشكل متكرر أكثر من مثيلاتها ذات الأولوية المنخفضة (ولكنها ستعمل).
+
يُعيد أولوية المهمة الفرعية التي استدعيت معه.
−
===[[Ruby/Thread/priority-3D | التابع priority=]]===
+
===[[Ruby/Thread/priority-3D|<code>priority=‎</code>]]===
−
يعين التابع <code>priority=</code> أولوية <code>thr</code> عند القيمة <code>integer</code> (انظر فقرة البنية العامة). سيتم تشغيل [[Ruby/Thread|المهمة الفرعية]] ذات الأولوية العالية بشكل متكرر أكثر من مثيلاتها ذات الأولوية المنخفضة (ولكنها ستعمل).
+
يعين عند استدعائه بالشكل <code>priority= integer</code> أولوية المهمة الفرعية التي استدعيت معه إلى القيمة <code>integer</code>.
−
===[[Ruby/Thread/raise | التابع raise]]===
+
===[[Ruby/Thread/raise|<code>raise</code>]]===
−
يطلق التابع <code>raise</code> استثناء من [[Ruby/Thread|مهمة فرعية]] معينة. لا يلزم أن يكون الُمستدعي (caller) من <code>thr</code>. انظر صفحة <code>[[Ruby/Kernel/raise|Kernel#raise]]</code> لمزيد من المعلومات.
+
يطلق استثناء من مهمة فرعية معينة.
−
===[[Ruby/Thread/report_on_exception | التابع report_on_exception]]===
+
===[[Ruby/Thread/report on exception|<code>report_on_exception</code>]]===
−
يعيد التابع <code>report_on_exception</code> حالة "report on exception".
+
يعيد حالة "التبليغ عند حصول استثناء" (report on exception) للمهمة الفرعية المحلية.
−
===[[Ruby/Thread/report_on_exception-3D | التابع report_on_exception=]]===
+
===[[Ruby/Thread/report on exception-3D|<code>report_on_exception=‎</code>]]===
−
يُعيد التابع <code>report_on_exception=</code> الحالة الجديدة. عند إعطائه القيمة <code>true</code>، سترث كل [[Ruby/Thread|المهمة الفرعية]] التي تم إنشاؤها بعد ذلك الشرط (condition) وتبعث رسالة على المجرى $ stderr إذا أدى استثناء ما إلى إنهاء [[Ruby/Thread|مهمة فرعية]]:
+
يضبط عند استدعائه بالشكل <code>report_on_exception= boolean</code> حالة "التبليغ عند حصول استثناء" (report on exception) للمهمة الفرعية المحلية المعطاة إلى القيمة <code>boolean</code>.
−
===[[Ruby/Thread/run | التابع run]]===
+
===[[Ruby/Thread/run|<code>run</code>]]===
−
يوقظ التابع <code>run</code> [[Ruby/Thread|المهمة الفرعية]] <code>thr</code>، مما يجعلها متاحة للجدولة.
+
يوقظ المهمة الفرعية، ويجعلها متاحة للجدولة.
−
===[[Ruby/Thread/safe_level | التابع safe_level]]===
+
===[[Ruby/Thread/safe level|<code>safe_level</code>]]===
−
يُعيد التابع <code>safe_level</code> المستوى الآمن لل[[Ruby/Thread|مهمة فرعية]] <code>thr</code>. يمكن أن يساعد تعيين مستويات الأمان المحلية [[Ruby/Thread|المهمة الفرعية]] (thread-local safe levels) عند تنفيذ أكواد برمجية غير آمنة.
+
يُعيد المستوى الآمن للمهمة فرعية.
−
===[[Ruby/Thread/set_trace_func | التابع set_trace_func]]===
+
===[[Ruby/Thread/set trace func|<code>set_trace_func</code>]]===
−
يجعل التابع <code>set_trace_func</code> الوسيط المعطى <code>proc</code> (انظر فقرة البنية العامة) معالجا للتعقب في [[Ruby/Thread|المهمة الفرعية]] <code>thr</code>، أو يعطل العقب إن كان الوسيط مساويا للقيمة <code>nil</code>.
+
يجعل الكائن <code>[[Ruby/Proc|proc]]</code> معالجًا للتعقب (handler for tracing) في المهمة الفرعية، أو يعطل التعقب إن كان مُرِّرت القيمة <code>nil</code> بدلًا من ذلك الكائن.
−
===[[Ruby/Thread/status | التابع status]]===
+
===[[Ruby/Thread/status|<code>status</code>]]===
−
يُعيد التابع <code>status</code> حالة <code>thr</code>.
+
يعيد حالة المهمة الفرعية.
−
===[[Ruby/Thread/stop-3F | التابع stop?‎]]===
+
===[[Ruby/Thread/stop-3F|<code>stop?‎</code>]]===
−
يُعيد التابع <code>stop?‎</code> القيمة <code>true</code> إن كانت [[Ruby/Thread|المهمة الفرعية]] <code>thr</code> ميتة أو نائمة.
+
يتحقق إن كانت المهمة الفرعية ميتة أو نائمة.
−
===[[Ruby/Thread/terminate | التابع terminate]]===
+
===[[Ruby/Thread/terminate|<code>terminate</code>]]===
−
ينهي التابع <code>terminate</code> [[Ruby/Thread|المهمة الفرعية]] <code>thr</code> ويُجدوِل [[Ruby/Thread|مهمة فرعية]] أخرى ليتم تشغيلها.
+
ينهي [[Ruby/Thread|المهمة الفرعية]] التي استدعيت معه ويُجدوِل مهمة فرعية أخرى ليتم تشغيلها.
−
===[[Ruby/Thread/thread_variable-3F | التابع thread_variable?‎]]===
+
===[[Ruby/Thread/thread variable-3F|<code>thread_variable?‎</code>]]===
−
يُعيد التابع <code>thread_variable?‎</code> القيمة <code>true</code> إن كانت [[Ruby/String|السلسلة النصية]] (أو الرمز) موجودة كمتغير محلى [[Ruby/Thread|المهمة الفرعية]] (thread-local variable).
+
يتحقق إن كانت <nowiki/>[[Ruby/String|السلسلة النصية]] أو الرمز المعطى موجودًا كمتغير محلي للمهمة الفرعية (thread-local variable).
−
===[[Ruby/Thread/thread_variable_get | التابع thread_variable_get]]===
+
===[[Ruby/Thread/thread variable get|<code>thread_variable_get</code>]]===
−
يُعيد التابع <code>thread_variable_get</code> قيمة المتغير المحلي في [[Ruby/Thread|المهمة الفرعية]] (thread local variable) الذي تم تعيينه. لاحظ أن هذه المتغيرات تختلف عن القيم محلية [[Ruby/Fiber|الألياف]] (fiber local values).  بالنسبة للقيم محلية [[Ruby/Fiber|الألياف]] (fiber local values)، يرجى الاطلاع على <code>[[Ruby/Thread/5B-5D|#[]]]</code> و <code>[[Ruby/Thread/5B-5D-3D|#[]=]]</code>.
+
يُعيد قيمة المتغير المحلي للمهمة الفرعية (thread local variable) الذي تم تعيينه. 
−
===[[Ruby/Thread/thread_variable_set | التابع thread_variable_set]]===
+
===[[Ruby/Thread/thread variable set|<code>thread_variable_set</code>]]===
−
يعين التابع <code>thread_variable_set</code> المتغيرا المحلي في [[Ruby/Thread|المهمة الفرعية]] (thread local) ذو الاسم <code>key</code> ويعطيه القيمة <code>[[Ruby/Thread/value|value]]</code> (انظر فقرة البنية العامة). لاحظ أن هذه المتغيرات محلية في [[Ruby/Thread|المهمة الفرعية]]، وليس في [[Ruby/Fiber|الألياف]].  يرجى الاطلاع على <code>[[Ruby/Thread/thread_variable_get|#thread_variable_get]]</code> و <code>[[Ruby/Thread/5B-5D|#[]]]</code> لمزيد من المعلومات.
+
يعين قيمة متغير محلي ذي اسم محدَّد في المهمة الفرعية (thread local) إلى قيمة معيَّنة.
−
===[[Ruby/Thread/thread_variables | التابع thread_variables]]===
+
===[[Ruby/Thread/thread variables|<code>thread_variables</code>]]===
−
يُعيد التابع <code>thread_variables</code> [[Ruby/Array|مصفوفة]] من أسماء المتغيرات المحلية في [[Ruby/Thread|المهمة الفرعية]] (thread-local) (على شكل رموز).
+
يُعيد [[Ruby/Array|مصفوفة]] من أسماء المتغيرات المحلية في المهمة الفرعية (thread-local) على شكل رموز.
−
===[[Ruby/Thread/to_s | التابع to_s]]===
+
===[[Ruby/Thread/to s|<code>to_s</code>]]===
−
يضع التابع <code>to_s</code> الاسم و رقم التعريف وحالة [[Ruby/Thread|المهمة الفرعية]] <code>thr</code> في [[Ruby/String|سلسلة نصية]].
+
يعيد اسم ومعرِّف وحالة مهمة فرعية على هيئة <nowiki/>[[Ruby/String|سلسلة نصية]].
−
===[[Ruby/Thread/value | التابع value]]===
+
===[[Ruby/Thread/value|<code>value</code>]]===
−
ينتظر التابع <code>value</code> اكتمال [[Ruby/Thread|المهمة الفرعية]] <code>thr</code>، باستخدام <code>[[Ruby/Thread/join|join]]</code>، ثم يُعيد قيمته، أو يطلق الاستثناء الذي أنهى [[Ruby/Thread|المهمة الفرعية]].
+
ينتظر اكتمال المهمة الفرعية، باستخدام التابع <code>[[Ruby/Thread/join|join]]</code> ثم يُعيد قيمتها، أو يطلق الاستثناء الذي أنهى المهمة الفرعية.
−
===[[Ruby/Thread/wakeup | التابع wakeup]]===
+
===[[Ruby/Thread/wakeup|<code>wakeup</code>]]===
−
يجعل التابع <code>wakeup</code> [[Ruby/Thread|مهمة فرعية]] معينة متاحة للجدولة، ومع ذلك فقد يظل معطلا في مجرى الإدخال/الإخراج (I/O).
+
يوقظ مهمة فرعية ويجعلها متاحة للجدولة، ولكن قد تظل معطلة في مجرى الإدخال/الإخراج (I/O).
 
==مصادر==
 
==مصادر==
−
*[http://ruby-doc.org/core-2.5.1/Thread.html قسم  الصنف Thread في توثيق روبي الرسمي.]
+
*[http://ruby-doc.org/core-2.5.1/Thread.html صفحة الصنف Thread في توثيق روبي الرسمي.]

المراجعة الحالية بتاريخ 08:51، 6 ديسمبر 2018

المهام الفرعية (Threads، وتدعى "الخيوط" أيضًا) هي الطريقة التي تنفذ بها روبي البرمجة المتزامنة (concurrent programming).

البرامج التي تتطلب تنفيذ عدة مهام فرعية يمكنها استخدام الصنف Thread. على سبيل المثال، يمكننا إنشاء مهمة فرعية جديدة منفصلة عن المهمة الرئيسية باستخدام التابع new.

thr = Thread.new { puts "Whats the big deal" }‎

ثم يمكننا إيقاف تنفيذ المهمة الفرعية الرئيسية مؤقتًا إلى حين إنتهاء المهمة الفرعية خاصتنا باستخدام التابع join:

thr.join #=> "Whats the big deal"‎

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

threads = []
threads << Thread.new { puts "Whats the big deal" }
threads << Thread.new { 3.times { puts "Threads are fun!" } }‎

بعد إنشاء عدد من المهام الفرعية، سننتظر إلى أن تنتهي جميعها بالتتابع.

threads.each { |thr| thr.join }‎

تهيئة المهام الفرعية

لإنشاء مهام فرعية جديدة، توفر روبي عدة توابع لذلك هي: new و start و fork. يجب تمرير كتلة مع كل هذه التوابع، وإلا سيُطلق الاستثناء ThreadError.

عند اشتقاق أصناف فرعية (subclasses) من Thread، فسيتم تجاهل التابع initialize الخاص بصنفك الفرعي من قبل التوابع start و fork. لذلك تأكد من استدعاء المتغير super في التابع initialize خاصتك.

إنهاء مهمة الفرعية

توفر روبي مجموعة متنوعة من الطرق لإنهاء المهام الفرعية. ينهي (أو يقتل) التابع kill مثلًا المهمة الفرعية المعطاة:

thr = Thread.new { ... }
Thread.kill(thr) # sends exit() to thr‎

أو يمكنك استخدام تابع النسخة exit، أو أحد الأسماء البديلة له وهي kill و terminate.

thr.exit‎

حالة مهمة الفرعية

توفر روبي عددًا من من توابع النسخة (instance methods) لاستخلاص حالة مهمة فرعية معينة. للحصول على سلسلة نصية تحتوي حالة المهمة الفرعية الحالية، استخدم التابع status:

thr = Thread.new { sleep }
thr.status # => "sleep"
thr.exit
thr.status # => false‎

يمكنك أيضًا استخدام التابع alive?‎ للتحقق مما إذا كانت المهمة الفرعية قيد التشغيل أو نائمة، أو التابع stop?‎ للتحقق مما إذا كانت المهمة الفرعية ميتة أو نائمة.

متغيرات ونطاق مهمة الفرعية

نظرًا لكون المهام الفرعية تُنشأ بواسطة الكتل، فستُطبَّق القواعد نفسها على كتل روبي الأخرى فيما يتعلق بنطاق (scope) المتغيرات. المتغيرات المحلية التي تم إنشاؤها داخل هذه الكتلة لا يمكن الوصول إليها إلا من داخل هذه المهمة الفرعية.

الألياف المحلية مقابل الخيوط المحلية

يحتوي كل ليف (fiber) على نطاق خاص به لتخزين العناصر المعيّنة من المعامل []. عندما تعيِّن ليفًا محليًّا (fiber-local)، فلن يمكن الوصول إليه إلا من داخل ذلك الليف. المثال التالي يوضح ذلك:

Thread.new {
  Thread.current[:foo] = "bar"
  Fiber.new {
    p Thread.current[:foo] # => nil
  }.resume
}.join‎

يستخدم هذا المثال معامل الفهرسة [] لأجل الاستخلاص، ويستخدم معامل التعيين =[] لأجل تعيين ليف محلي (fiber-locals)؛ يمكنك أيضًا استخدام التابع keys لإنشاء قائمة بالألياف المحلية لمهمة فرعية معينة، أو التابع key?‎ للتحقق من وجود ألياف محلية. يمكن الوصول إلى المتغيرات المحلية في المهمة الفرعية (thread-locals) من أي مكان في نطاق تلك المهمة. إليك المثال التالي:

Thread.new{
  Thread.current.thread_variable_set(:foo, 1)
  p Thread.current.thread_variable_get(:foo) # => 1
  Fiber.new{
    Thread.current.thread_variable_set(:foo, 2)
    p Thread.current.thread_variable_get(:foo) # => 2
  }.resume
  p Thread.current.thread_variable_get(:foo)   # => 2
}.join‎

يمكنك أن ترى أن المتغير ‎:foo محلي المهمة الفرعية قد وصل إلى نطاق الليف، ثم تم تغييره إلى القيمة 2 في نهاية المهمة الفرعية.

هذا المثال يستخدم التابع thread_variable_set لإنشاء مهمة فرعية جديدة، ويستخدم thread_variable_get للرجوع إليها.

يمكن أيضًا استخدام التابع thread_variables لإنشاء قائمة بجميع المتغيرات المحلية في مهمة فرعية (thread-locals)، والتابع thread_variable?‎ للتحقق من وجود متغير محلي معين في مهمة فرعية.

معالجة الاستثناءات

يمكن لأي مهمة فرعية إطلاق استثناء باستخدام تابع النسخة raise، والذي يعمل بطريقة مشابهة للتابع Kernel.raise.

من الجدير بالذكر أنّ الاستثناءات التي تُطلق من أي مهمة الفرعية، باستثناء الرئيسية (main thread)، التي تعتمد على abort_on_exception. قيمة هذا الخيار الافتراضية هي false، مما يعني أن أي استثناء غير مُعالَج سيؤدي إلى إنهاء المهمة الفرعية بصمت عند الانتظار سواءً من join أو من value. يمكنك تغيير هذا الإعداد الافتراضي عبر استدعاء abort_on_exception= true، أو من خلال إعطاء التابع DEBUG القيمة true.

مع إضافة تابع الصنف handle_interrupt، يمكنك الآن معالجة الاستثناءات بشكل غير متزامن بالمهام الفرعية.

الجدولة (Scheduling)

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

بمجرد أن تصبح المهمة الفرعية في حالة نوم، يمكنك استخدام التابع wakeup لجعلها متاحة للجدولة.

يمكنك أيضًا استخدام التابع pass، والذي يحاول تمرير التنفيذ إلى مهمة فرعية أخرى؛ مسألة استبدال المهمة الفرعية قيد التشغيل تتعلق بنظام التشغيل المستخدم. وينطبق الأمر ذاته على التابع priority، والذي يتيح لك الطلب من مُجدوِل المهام الفرعية (thread scheduler) إعطاء الأسبقية لمهام فرعية معينة عند التنفيذ. يعتمد هذا التابع أيضًا على نظام التشغيل، وقد يُتجاهَل في بعض الأنظمة.

توابع الصنف العامة

DEBUG

يُعيد مستوى التصحيح في المهمة الفرعية (thread debug level).

DEBUG=‎

يعيّن عند استدعائه بالشكل DEBUG = num قيمة مستوى تصحيح المهمة الفرعية (thread debug level) إلى القيمة num.

abort_on_exception

يُعيد حالة الشرط العام "المقاطعة عند حدوث استثناء؟" (abort on exception). 

abort_on_exception=‎

يضبط عند استدعائه بالشكل abort_on_exception= boolean حالة الشرط العام "المقاطعة عند حدوث استثناء؟" (abort on exception) إلى القيمة المنطقية boolean.

current

يُعيد المهمة الفرعية المُنفّذة حاليًّا.

exclusive

يغلف الكتلة المعطاة في دالة الآلة الافتراضية العامة (VM-global)‏Mutex.synchronize، ثم يعيد قيمة الكتلة.

exit

ينهي المهمة الفرعية قيد التشغيل، ويُجدول مهمة فرعية أخرى ليتم تشغيلها.

fork

ينشئ عملية فرعية جديدة بشكل مكافئ للتابع new.

handle_interrupt

يغير توقيت المقاطعة غير المتزامنة (asynchronous interrupt timing).

kill

ينهي المهمة الفرعية المعطاة.

list

يُعيد مصفوفة من المهام الفرعية العاملة أو المتوقفة.

main

يُعيد المهمة الفرعية الرئيسية.

new

ينشئ مهمة فرعية جديدة تقوم بتنفيذ الكتلة المعطاة.

pass

يعطي إلى مُجدوِل المهمة الفرعية تلميحًا لتمرير التنفيذ إلى مهمة فرعية أخرى.

pending_interrupt?‎

يتحقق مما إذا كان طابور الانتظار غير المتزامن فارغًا أم لا.

report_on_exception

يعيد حالة "التبليغ عند الاستثناء" (report on exception). 

report_on_exception=‎

يضبط عند استدعائه بالشكل report_on_exception= boolean‎ حالة "التبليغ عند الاستثناء" (report on exception).

start

يشبه التابع new بشكل أساسي إلا أنه عند اشتقاق صنف فرعي (subclassed) من Thread، فإنَّ استدعاء start في ذلك الصنف الفرعي لن يستدعي تابع الصنف الفرعيinitialize.

stop

يوقف تنفيذ المهمة الفرعية الحالية، ويضعها في حالة "نوم" (sleep)، ويُجدوٍل (schedules) تنفيذ مهمة فرعية أخرى.

تزوابع النسخة العامة (Public Instance Methods)

[]

يُعيد قيمة متغير محلي الليف fiber) local variable، أو الليف الأصلي للمهمة الفرعية الحالية إن لم يكن المتغير موجودًا داخل ليف) باستخدام إما رمز أو سلسلة نصية.

=[]

يعيّن عندما يُستدعى بالشكل thr[sym] = obj قيمة المتغير sym محلي الليف (fiber-local variable)، باستخدام إما الرمز أو السلسلة النصية obj أو ينشئها.

abort_on_exception

يُعيد حالة الشرط المحلي (thread-local‏) "المقاطعة عند حدوث استثناء؟" (abort on exception) في المهمة الفرعية التي استُدعي معها.

abort_on_exception=‎

يضبط عند استدعائه بالشكل abort_on_exception= boolean حالة الشرط المحلي "المقاطعة عند حدوث استثناء؟" (abort on exception) إلى القيمة المنطقية boolean.

add_trace_func

يضيف عملية (كائنًا من النوع Proc) كمعالج للتعقب (tracing) إلى المهمة الفرعية التي استدعيت معه.

alive?‎

يتحقق إن كانت المهمة الفرعية التي استُدعي معها قيد التشغيل أو نائمة.

backtrace

يُعيد التعقب (backtrace) الحالي للمهمة فرعية التي استدعي معها.

backtrace_locations

يُعيد مكدس التنفيذ (execution stack) الخاص بالمهمة الفرعية على شكل مصفوفة تحتوي على كائنات التعقب (backtrace location objects).

fetch

(لم يوثَّق بعد.)

exit

ينهي المهمة الفرعية قيد التشغيل حاليًا، ويُجدوِل (schedules) مهمة فرعية أخرى ليتم تشغيلها.

group

يُعيد مجموعة الخيوط ThreadGroup التي تحتوي على المهمة الفرعية المعطاة، أو يُعيد nil إذا لم تكن المهمة الفرعية عضوًا في أي مجموعة.

inspect

يعيد اسم ورقم تعريف وحالة المهمة الفرعية على هيئة سلسلة نصية.

join

يوقف عند استدعائه تنفيذ المهمة الفرعية المُستدعيَة (calling thread)، وبدء تنفيذ المهمة الفرعية التي استُدعي معها.

key?‎

يتحقق إن كانت السلسلة النصية أو الرمز المعطى موجود على هيئة متغير محلي الليف(fiber-local variable).

keys

يُعيد مصفوفة من أسماء المتغيرات محلية الليف (على هيئة رموز).

kill

ينهي المهمة الفرعية التي استُدعي معها، ثم يجدول مهمة فرعية أخرى لتنفيذها.

name

يعيد اسم المهمة الفرعية.

name=‎

يعين اسم المهمة الفرعية التي استدعيت معه إلى الاسم المُمرَّر إليه.

pending_interrupt?‎

يتحقق مما إذا كان طابور الانتظار غير المتزامن فارغًا أم لا.

priority

يُعيد أولوية المهمة الفرعية التي استدعيت معه.

priority=‎

يعين عند استدعائه بالشكل priority= integer أولوية المهمة الفرعية التي استدعيت معه إلى القيمة integer.

raise

يطلق استثناء من مهمة فرعية معينة.

report_on_exception

يعيد حالة "التبليغ عند حصول استثناء" (report on exception) للمهمة الفرعية المحلية.

report_on_exception=‎

يضبط عند استدعائه بالشكل report_on_exception= boolean حالة "التبليغ عند حصول استثناء" (report on exception) للمهمة الفرعية المحلية المعطاة إلى القيمة boolean.

run

يوقظ المهمة الفرعية، ويجعلها متاحة للجدولة.

safe_level

يُعيد المستوى الآمن للمهمة فرعية.

set_trace_func

يجعل الكائن proc معالجًا للتعقب (handler for tracing) في المهمة الفرعية، أو يعطل التعقب إن كان مُرِّرت القيمة nil بدلًا من ذلك الكائن.

status

يعيد حالة المهمة الفرعية.

stop?‎

يتحقق إن كانت المهمة الفرعية ميتة أو نائمة.

terminate

ينهي المهمة الفرعية التي استدعيت معه ويُجدوِل مهمة فرعية أخرى ليتم تشغيلها.

thread_variable?‎

يتحقق إن كانت السلسلة النصية أو الرمز المعطى موجودًا كمتغير محلي للمهمة الفرعية (thread-local variable).

thread_variable_get

يُعيد قيمة المتغير المحلي للمهمة الفرعية (thread local variable) الذي تم تعيينه. 

thread_variable_set

يعين قيمة متغير محلي ذي اسم محدَّد في المهمة الفرعية (thread local) إلى قيمة معيَّنة.

thread_variables

يُعيد مصفوفة من أسماء المتغيرات المحلية في المهمة الفرعية (thread-local) على شكل رموز.

to_s

يعيد اسم ومعرِّف وحالة مهمة فرعية على هيئة سلسلة نصية.

value

ينتظر اكتمال المهمة الفرعية، باستخدام التابع join ثم يُعيد قيمتها، أو يطلق الاستثناء الذي أنهى المهمة الفرعية.

wakeup

يوقظ مهمة فرعية ويجعلها متاحة للجدولة، ولكن قد تظل معطلة في مجرى الإدخال/الإخراج (I/O).

مصادر

مجلوبة من "https://wiki.hsoub.com/index.php?title=Ruby/Thread&oldid=25928"