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

أسئلة المقابلة متعددة الخيوط

1) ما هو تعدد الخيوط؟

تعدد مؤشرات الترابط هو عملية تنفيذ مؤشرات ترابط متعددة في وقت واحد. يتم استخدام مؤشرات الترابط المتعددة للحصول على تعدد المهام. يستهلك ذاكرة أقل ويعطي أداء سريع وفعال. مزاياها الرئيسية هي:

• المواضيع تشترك في نفس مساحة العنوان.
• الخيط خفيف الوزن.
• تكلفة الاتصال بين العمليات منخفضة.

2) ما هو الخيط؟

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

3) التفريق بين العملية والخيط؟

هناك الاختلافات التالية بين العملية والخيط.

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

4) ماذا تفهم من التواصل بين الخيوط؟

• تسمى عملية الاتصال بين الخيوط المتزامنة بالاتصال بين الخيوط.
• يتم استخدام الاتصال بين الخيوط لتجنب استقصاء الخيوط في Java.
• يتم إيقاف تشغيل مؤشر الترابط مؤقتًا في القسم الحرج الخاص به، ويُسمح لمؤشر ترابط آخر بالدخول (أو القفل) في نفس القسم الحرج ليتم تنفيذه.
• يمكن الحصول عليه عن طريق طرق الانتظار () وإخطار () وإخطار الكل ().

5) ما هو الغرض من طريقة الانتظار () في جافا؟

يتم توفير طريقة الانتظار () بواسطة فئة الكائن في Java. تُستخدم هذه الطريقة للاتصال بين سلاسل المحادثات في Java. يتم استخدام java.lang.Object.wait() لإيقاف مؤشر الترابط الحالي مؤقتًا، والانتظار حتى لا يستدعي مؤشر ترابط آخر أسلوب notify() أو notifyAll(). ويرد بناء الجملة أدناه.

انتظار الفراغ النهائي العام ()

6) لماذا يجب استدعاء طريقة الانتظار () من الكتلة المتزامنة؟

يجب أن نستدعي طريقة الانتظار وإلا فسوف يتم رميها java.lang.IllegalMonitorStateException استثناء. علاوة على ذلك، نحتاج إلى طريقة الانتظار () للاتصال بين الخيوط مع notify () وnotifyAll (). لذلك يجب أن يكون موجودًا في الكتلة المتزامنة من أجل الاتصال الصحيح والصحيح.

7) ما هي مزايا تعدد الخيوط؟

تتمتع البرمجة متعددة الخيوط بالمزايا التالية:

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

8) ما هي الحالات في دورة حياة الخيط؟

يمكن أن يكون للخيط إحدى الحالات التالية خلال فترة حياته:

جديد:في هذه الحالة، يتم إنشاء كائن فئة مؤشر الترابط باستخدام عامل تشغيل جديد، ولكن مؤشر الترابط ليس على قيد الحياة. لا يبدأ الموضوع حتى نستدعي طريقة start ().قابل للتشغيل:في هذه الحالة، يكون مؤشر الترابط جاهزًا للتشغيل بعد استدعاء أسلوب start(). ومع ذلك، لم يتم تحديد مؤشر الترابط بعد بواسطة جدولة مؤشر الترابط.جري:في هذه الحالة، يقوم برنامج جدولة مؤشر الترابط باختيار مؤشر الترابط من حالة الاستعداد، ويتم تشغيل مؤشر الترابط.الانتظار/المحظورة:في هذه الحالة، لا يكون الخيط قيد التشغيل ولكنه لا يزال على قيد الحياة، أو أنه ينتظر انتهاء الخيط الآخر.ميت/منتهٍ:يكون الخيط في حالة منتهية أو ميتة عند خروج طريقة التشغيل ().

9) ما الفرق بين الجدولة الوقائية وتقسيم الوقت؟

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

10) ما هو تبديل السياق؟

في تبديل السياق، يتم تخزين حالة العملية (أو مؤشر الترابط) بحيث يمكن استعادتها ويمكن استئناف التنفيذ من نفس النقطة لاحقًا. يتيح تبديل السياق للعمليات المتعددة مشاركة نفس وحدة المعالجة المركزية.

11) هل تفرق بين فئة الموضوع والواجهة القابلة للتشغيل لإنشاء موضوع؟

يمكن إنشاء الخيط باستخدام طريقتين.

• عن طريق توسيع فئة الموضوع
• من خلال تنفيذ واجهة Runnable

ومع ذلك، فإن الاختلافات الأساسية بين كلتا الطريقتين مذكورة أدناه:

• من خلال توسيع فئة Thread، لا يمكننا توسيع أي فئة أخرى، لأن Java لا تسمح بالوراثة المتعددة أثناء تنفيذ الواجهة القابلة للتشغيل؛ يمكننا أيضًا تمديد فئة أساسية أخرى (إذا لزم الأمر).
• من خلال توسيع فئة Thread، يقوم كل مؤشر ترابط بإنشاء كائن فريد ويرتبط به أثناء تنفيذ الواجهة القابلة للتشغيل؛ مؤشرات الترابط المتعددة تشترك في نفس الكائن
• توفر فئة Thread طرقًا مدمجة متنوعة مثل getPriority() وisAlive وغيرها الكثير بينما توفر الواجهة Runnable طريقة واحدة، أي run().

12) ما هي طريقة الانضمام ()؟

تنتظر طريقة join () موت الخيط. بمعنى آخر، يتسبب في توقف تنفيذ مؤشرات الترابط قيد التشغيل حاليًا حتى يكمل مؤشر الترابط الذي ينضم إليه مهمته. يتم تحميل طريقة الانضمام بشكل زائد في فئة Thread بالطرق التالية.

• انضمام الفراغ العام () يلقي InterruptedException
• انضمام الفراغ العام (ملي ثانية طويلة) يلقي InterruptedException

13) وصف الغرض وعمل طريقة النوم ().

يتم استخدام طريقة السكون () في جافا لحظر سلسلة رسائل لفترة معينة، مما يعني أنها توقف تنفيذ سلسلة الرسائل لفترة محددة. هناك طريقتان للقيام بذلك.

بناء الجملة:

محسّن للحلقة Java

• يؤدي السكون الفارغ الثابت العام (ملي ثانية طويلة) إلى طرح InterruptedException
• يؤدي السكون الفارغ الثابت العام (ملي ثانية طويلة، int nanos) إلى طرح InterruptedException

طريقة عمل النوم ().

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

14) ما الفرق بين طريقة الانتظار () والنوم ()؟

15) هل من الممكن بدء الموضوع مرتين؟

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

 public class Multithread1 extends Thread { public void run() { try { System.out.println('thread is executing now........'); } catch(Exception e) { } } public static void main (String[] args) { Multithread1 m1= new Multithread1(); m1.start(); m1.start(); } } 

انتاج |

 thread is executing now........ Exception in thread 'main' java.lang.IllegalThreadStateException at java.lang.Thread.start(Thread.java:708) at Multithread1.main(Multithread1.java:13) 

16) هل يمكننا استدعاء طريقة التشغيل () بدلاً من البدء ()؟

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

17) ماذا عن المواضيع الخفية؟

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

مجموعة الفراغ العام Daemon (الحالة المنطقية):يتم استخدامه لتمييز مؤشر الترابط الخفي أو مؤشر ترابط المستخدم.المنطقية العامة isDaemon ():إنه يتحقق من أن الخيط خفي أم لا.

18) هل يمكننا أن نجعل خيط المستخدم كخيط خفي إذا بدأ الخيط؟

لا، إذا قمت بذلك، فسيتم طرح IllegalThreadStateException. لذلك، لا يمكننا إنشاء خيط خفي إلا قبل بدء الخيط.

 class Testdaemon1 extends Thread{ public void run(){ System.out.println('Running thread is daemon...'); } public static void main (String[] args) { Testdaemon1 td= new Testdaemon1(); td.start(); setDaemon(true);// It will throw the exception: td. } } 

انتاج |

 Running thread is daemon... Exception in thread 'main' java.lang.IllegalThreadStateException at java.lang.Thread.setDaemon(Thread.java:1359) at Testdaemon1.main(Testdaemon1.java:8) 

19) ما هو ربط الاغلاق؟

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

 public�void�addShutdownHook(Thread�hook){}�� Runtime r=Runtime.getRuntime(); r.addShutdownHook(new MyThread()); 

بعض النقاط المهمة حول خطافات إيقاف التشغيل هي:

• تمت تهيئة خطافات إيقاف التشغيل ولكن لا يمكن تشغيلها إلا عند حدوث إيقاف تشغيل JVM.
• تعتبر خطافات إيقاف التشغيل أكثر موثوقية من أداة Finalizer() نظرًا لوجود فرص أقل جدًا لعدم تشغيل خطافات إيقاف التشغيل.
• يمكن إيقاف ربط إيقاف التشغيل عن طريق استدعاء طريقة التوقف (int) لفئة وقت التشغيل.

20)متى يجب أن نقطع الخيط؟

يجب علينا مقاطعة الخيط عندما نريد كسر وضع السكون أو انتظار حالة الخيط. يمكننا مقاطعة خيط ما عن طريق استدعاء المقاطعة() - ورمي InterruptedException.

متى ينتهي Q1

21) ما هو التزامن؟

المزامنة هي القدرة على التحكم في وصول سلاسل رسائل متعددة إلى أي مورد مشترك. يتم استخدامها:

1. لمنع تداخل الخيط.
2. لمنع مشكلة الاتساق.

عندما تحاول سلاسل العمليات المتعددة القيام بنفس المهمة، هناك احتمال حدوث نتيجة خاطئة، وبالتالي لإزالة هذه المشكلة، تستخدم Java عملية المزامنة التي تسمح بتنفيذ مؤشر ترابط واحد فقط في المرة الواحدة. يمكن تحقيق المزامنة بثلاث طرق:

• بالطريقة المتزامنة
• بواسطة كتلة متزامنة
• عن طريق المزامنة الثابتة

بناء الجملة للكتلة المتزامنة

 synchronized(object reference expression) { //code block } 

22) ما هو الغرض من الكتلة المتزامنة؟

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

• يتم استخدام الكتلة المتزامنة لقفل كائن لأي مورد مشترك.
• يقتصر نطاق الكتلة المتزامنة على الكتلة التي يتم تطبيقها عليها. نطاقها أصغر من الطريقة.

23) هل يمكن تأمين كائن Java للاستخدام الحصري بواسطة مؤشر ترابط معين؟

نعم. يمكنك قفل كائن ما بوضعه في كتلة 'متزامنة'. الكائن المقفل غير قابل للوصول إلى أي مؤشر ترابط آخر غير الكائن الذي طالب به بشكل صريح.

24) ما هو التزامن الثابت؟

إذا قمت بإجراء أي طريقة ثابتة متزامنة، فسيكون القفل على الفئة وليس على الكائن. إذا استخدمنا الكلمة الأساسية المتزامنة قبل الطريقة، فسيتم قفل الكائن (يمكن لخيط واحد الوصول إلى كائن في المرة الواحدة) ولكن إذا استخدمنا المزامنة الثابتة، فسيتم قفل الفصل (يمكن لخيط واحد الوصول إلى الفصل في كل مرة). المزيد من التفاصيل.

25) ما الفرق بين notify() و notifyAll()؟

يتم استخدام notify () لإلغاء حظر مؤشر ترابط واحد قيد الانتظار بينما يتم استخدام طريقة notifyAll () لإلغاء حظر جميع سلاسل الرسائل في حالة الانتظار.

26) ما هو الجمود؟

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

27) كيف يتم الكشف عن حالة الجمود؟ وكيف يمكن تجنبها؟

يمكننا اكتشاف حالة الجمود عن طريق تشغيل الكود على cmd وتجميع Thread Dump، وفي حالة وجود أي حالة توقف تام في الكود، ستظهر رسالة على cmd.

طرق تجنب حالة الجمود في Java:

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

28) ما هو جدولة المواضيع في جافا؟

في Java، عندما نقوم بإنشاء سلاسل الرسائل، يتم الإشراف عليها بمساعدة برنامج جدولة الخيوط، وهو جزء من JVM. جدولة سلسلة الرسائل مسؤولة فقط عن تحديد سلسلة المحادثات التي يجب تنفيذها. يستخدم برنامج جدولة سلاسل الرسائل آليتين لجدولة سلاسل الرسائل: الوقائي وتقسيم الوقت.

• فهو يختار أولوية الموضوع.
• فهو يحدد وقت الانتظار لموضوع
• فإنه يتحقق من طبيعة الموضوع

29) هل لكل خيط مكدس خاص به في البرمجة متعددة الخيوط؟

نعم، في البرمجة متعددة الخيوط، يحتفظ كل خيط بمساحة مكدس خاصة به أو منفصلة في الذاكرة، مما يجعل كل خيط مستقلاً عن الآخر.

30) كيف يتم تحقيق سلامة الخيط؟

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

• التزامن
• استخدام الكلمة الأساسية المتقلبة
• باستخدام آلية تعتمد على القفل
• استخدام فئات المجمع الذرية

31) ما هي حالة العرق؟

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

32) ما هي الكلمة الأساسية المتقلبة في جافا؟

يتم استخدام الكلمة الأساسية المتطايرة في البرمجة متعددة الخيوط لتحقيق أمان الخيط، حيث يكون التغيير في متغير واحد مرئيًا لجميع الخيوط الأخرى بحيث يمكن استخدام متغير واحد بواسطة خيط واحد في المرة الواحدة.

33) ماذا تفهم من تجمع الخيوط؟

• يمثل تجمع Java Thread مجموعة من سلاسل العمليات العاملة التي تنتظر تخصيص المهمة.
• يتم الإشراف على الخيوط الموجودة في تجمع الخيوط من قبل مزود الخدمة الذي يقوم بسحب مؤشر ترابط واحد من التجمع وتعيين مهمة له.
• بعد الانتهاء من المهمة المحددة، عاد مؤشر الترابط مرة أخرى إلى تجمع سلاسل الرسائل.
• يعتمد حجم تجمع مؤشرات الترابط على إجمالي عدد مؤشرات الترابط المحفوظة للتنفيذ.

مزايا تجمع الخيوط هي:

• باستخدام تجمع مؤشرات الترابط، يمكن تحسين الأداء.
• باستخدام تجمع مؤشرات الترابط، يمكن أن يحدث استقرار أفضل للنظام.

أسئلة المقابلة المتزامنة

34) ما هي المكونات الرئيسية لواجهة برمجة التطبيقات المتزامنة؟

يمكن تطوير Concurrency API باستخدام فئة وواجهات الحزمة java.util.Concurrent. توجد الفئات والواجهات التالية في الحزمة java.util.Concurrent.

• المنفذ
• FarkJoinPool
• ExecutorService
• خدمة تنفيذية مجدولة
• مستقبل
• وحدة الوقت (التعداد)
• CountDownLatch
• CyclicBarrier
• إشارة
• ThreadFactory
• BlockingQueue
• DelayQueue
• أقفال
• فيزر

35) ما هي واجهة المنفذ في Concurrency API في Java؟

واجهة المنفذ التي توفرها الحزمة java.util.concurrent هي الواجهة البسيطة المستخدمة لتنفيذ المهمة الجديدة. يتم استخدام طريقة التنفيذ () لواجهة المنفذ لتنفيذ بعض الأوامر المحددة. بناء جملة طريقة التنفيذ () موضح أدناه.

تنفيذ باطل (أمر قابل للتشغيل)

خذ بعين الاعتبار المثال التالي:

هبة البخاري

 import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { Executor e = Executors.newCachedThreadPool(); e.execute(new Thread()); ThreadPoolExecutor pool = (ThreadPoolExecutor)e; pool.shutdown(); } static class Thread implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 5); System.out.println('Running Thread!'); TimeUnit.SECONDS.sleep(duration); System.out.println('Thread Completed'); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } 

انتاج |

 Running Thread! Thread Completed 

36) ما هو BlockingQueue؟

java.util.concurrent.BlockingQueue هي الواجهة الفرعية لقائمة الانتظار التي تدعم العمليات مثل انتظار توفر المساحة قبل إدراج قيمة جديدة أو انتظار أن تصبح قائمة الانتظار غير فارغة قبل استرجاع عنصر منها. النظر في المثال التالي.

 import java.util.Random; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { BlockingQueue queue = new ArrayBlockingQueue(10); Insert i = new Insert(queue); Retrieve r = new Retrieve(queue); new Thread(i).start(); new Thread(r).start(); Thread.sleep(2000); } static class Insert implements Runnable { private BlockingQueue queue; public Insert(BlockingQueue queue) { this.queue = queue; } @Override public void run() { Random random = new Random(); try { int result = random.nextInt(200); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); result = random.nextInt(10); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); result = random.nextInt(50); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); } catch (InterruptedException e) { e.printStackTrace(); } } } static class Retrieve implements Runnable { private BlockingQueue queue; public Retrieve(BlockingQueue queue) { this.queue = queue; } @Override public void run() { try { System.out.println('Removed: ' + queue.take()); System.out.println('Removed: ' + queue.take()); System.out.println('Removed: ' + queue.take()); } catch (InterruptedException e) { e.printStackTrace(); } } } } 

انتاج |

 Added: 96 Removed: 96 Added: 8 Removed: 8 Added: 5 Removed: 5 

37) كيفية تنفيذ مشكلة المنتج والمستهلك باستخدام BlockingQueue؟

يمكن حل مشكلة المنتج والمستهلك باستخدام BlockingQueue بالطريقة التالية.

 import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.logging.Level; import java.util.logging.Logger; public class ProducerConsumerProblem { public static void main(String args[]){ //Creating shared object BlockingQueue sharedQueue = new LinkedBlockingQueue(); //Creating Producer and Consumer Thread Thread prod = new Thread(new Producer(sharedQueue)); Thread cons = new Thread(new Consumer(sharedQueue)); //Starting producer and Consumer thread prod.start(); cons.start(); } } //Producer Class in java class Producer implements Runnable { private final BlockingQueue sharedQueue; public Producer(BlockingQueue sharedQueue) { this.sharedQueue = sharedQueue; } @Override public void run() { for(int i=0; i<10; i++){ try { system.out.println('produced: ' + i); sharedqueue.put(i); } catch (interruptedexception ex) logger.getlogger(producer.class.getname()).log(level.severe, null, ex); consumer class in java implements runnable{ private final blockingqueue sharedqueue; public (blockingqueue sharedqueue) this.sharedqueue="sharedQueue;" @override void run() while(true){ system.out.println('consumed: '+ sharedqueue.take()); logger.getlogger(consumer.class.getname()).log(level.severe, < pre> <p> <strong>Output</strong> </p> <pre> Produced: 0 Produced: 1 Produced: 2 Produced: 3 Produced: 4 Produced: 5 Produced: 6 Produced: 7 Produced: 8 Produced: 9 Consumed: 0 Consumed: 1 Consumed: 2 Consumed: 3 Consumed: 4 Consumed: 5 Consumed: 6 Consumed: 7 Consumed: 8 Consumed: 9 </pre> <hr> <h3>38) What is the difference between Java Callable interface and Runnable interface?</h3> <p>The Callable interface and Runnable interface both are used by the classes which wanted to execute with multiple threads. However, there are two main differences between the both : </p> <ul> <li>A Callable interface can return a result, whereas the Runnable interface cannot return any result.</li> <li>A Callable interface can throw a checked exception, whereas the Runnable interface cannot throw checked exception. </li> <li>A Callable interface cannot be used before the Java 5 whereas the Runnable interface can be used.</li> </ul> <hr> <h3>39) What is the Atomic action in Concurrency in Java?</h3> <ul> <li>The Atomic action is the operation which can be performed in a single unit of a task without any interference of the other operations.</li> <li>The Atomic action cannot be stopped in between the task. Once started it fill stop after the completion of the task only. </li> <li>An increment operation such as a++ does not allow an atomic action.</li> <li>All reads and writes operation for the primitive variable (except long and double) are the atomic operation.</li> <li>All reads and writes operation for the volatile variable (including long and double) are the atomic operation.</li> <li>The Atomic methods are available in java.util.Concurrent package. </li> </ul> <hr> <h3>40) What is lock interface in Concurrency API in Java?</h3> <p>The java.util.concurrent.locks.Lock interface is used as the synchronization mechanism. It works similar to the synchronized block. There are a few differences between the lock and synchronized block that are given below.</p> <ul> <li>Lock interface provides the guarantee of sequence in which the waiting thread will be given the access, whereas the synchronized block doesn&apos;t guarantee it.</li> <li>Lock interface provides the option of timeout if the lock is not granted whereas the synchronized block doesn&apos;t provide that.</li> <li>The methods of Lock interface, i.e., Lock() and Unlock() can be called in different methods whereas single synchronized block must be fully contained in a single method.</li> </ul> <hr> <h3>41) Explain the ExecutorService Interface.</h3> <p>The ExecutorService Interface is the subinterface of Executor interface and adds the features to manage the lifecycle. Consider the following example.</p> <pre> import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { ExecutorService e = Executors.newSingleThreadExecutor(); try { e.submit(new Thread()); System.out.println(&apos;Shutdown executor&apos;); e.shutdown(); e.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException ex) { System.err.println(&apos;tasks interrupted&apos;); } finally { if (!e.isTerminated()) { System.err.println(&apos;cancel non-finished tasks&apos;); } e.shutdownNow(); System.out.println(&apos;shutdown finished&apos;); } } static class Task implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 20); System.out.println(&apos;Running Task!&apos;); TimeUnit.SECONDS.sleep(duration); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } </pre> <p> <strong>Output</strong> </p> <pre> Shutdown executor shutdown finished </pre> <hr> <h3>42) What is the difference between Synchronous programming and Asynchronous programming regarding a thread?</h3> <p> <strong>Synchronous programming: </strong> In Synchronous programming model, a thread is assigned to complete a task and hence thread started working on it, and it is only available for other tasks once it will end the assigned task.</p> <p> <strong>Asynchronous Programming: </strong> In Asynchronous programming, one job can be completed by multiple threads and hence it provides maximum usability of the various threads.</p> <hr> <h3>43) What do you understand by Callable and Future in Java?</h3> <p> <strong>Java Callable interface: </strong> In Java5 callable interface was provided by the package java.util.concurrent. It is similar to the Runnable interface but it can return a result, and it can throw an Exception. It also provides a run() method for execution of a thread. Java Callable can return any object as it uses Generic.</p> <p> <strong>Syntax:</strong> </p> <p>public interface Callable</p> <p> <strong>Java Future interface:</strong> Java Future interface gives the result of a concurrent process. The Callable interface returns the object of java.util.concurrent.Future.</p> <p>Java Future provides following methods for implementation.</p> <ul> <tr><td>cancel(boolean&#xFFFD;mayInterruptIfRunning):</td> It is used to cancel the execution of the assigned task. </tr><tr><td>get():</td> It waits for the time if execution not completed and then retrieved the result. </tr><tr><td>isCancelled():</td> It returns the Boolean value as it returns true if the task was canceled before the completion. </tr><tr><td>isDone():</td> It returns true if the job is completed successfully else returns false. </tr></ul> <hr> <h3>44. What is the difference between ScheduledExecutorService and ExecutorService interface?</h3> <p>ExecutorServcie and ScheduledExecutorService both are the interfaces of java.util.Concurrent package but scheduledExecutorService provides some additional methods to execute the Runnable and Callable tasks with the delay or every fixed time period.</p> <h3>45) Define FutureTask class in Java? </h3> <p>Java FutureTask class provides a base implementation of the Future interface. The result can only be obtained if the execution of one task is completed, and if the computation is not achieved then get method will be blocked. If the execution is completed, then it cannot be re-started and can&apos;t be canceled.</p> <p> <strong>Syntax</strong> </p> <p>public class FutureTask extends Object implements RunnableFuture</p> <hr></10;>

38) ما الفرق بين واجهة Java القابلة للاستدعاء والواجهة القابلة للتشغيل؟

يتم استخدام الواجهة القابلة للاستدعاء والواجهة القابلة للتشغيل من قبل الفئات التي تريد تنفيذها باستخدام سلاسل رسائل متعددة. ومع ذلك، هناك نوعان من الاختلافات الرئيسية بين كليهما:

• يمكن للواجهة القابلة للاستدعاء إرجاع نتيجة، بينما لا يمكن للواجهة القابلة للتشغيل إرجاع أي نتيجة.
• يمكن للواجهة القابلة للاستدعاء أن تطرح استثناءً محددًا، بينما لا يمكن للواجهة القابلة للتشغيل أن تطرح استثناءً محددًا.
• لا يمكن استخدام الواجهة القابلة للاستدعاء قبل Java 5 بينما يمكن استخدام الواجهة القابلة للتشغيل.

39) ما هو العمل الذري في التزامن في جافا؟

• الإجراء الذري هو العملية التي يمكن تنفيذها في وحدة واحدة من المهمة دون أي تدخل في العمليات الأخرى.
• لا يمكن إيقاف الإجراء الذري بين المهمة. وبمجرد البدء فإنه يملأ التوقف بعد الانتهاء من المهمة فقط.
• عملية الزيادة مثل ++ لا تسمح بإجراء ذري.
• جميع عمليات القراءة والكتابة للمتغير البدائي (ما عدا الطويلة والمزدوجة) هي عملية ذرية.
• جميع عمليات القراءة والكتابة للمتغير المتقلب (بما في ذلك الطويلة والمزدوجة) هي العملية الذرية.
• تتوفر الطرق الذرية في الحزمة java.util.Concurrent.

40) ما هي واجهة القفل في Concurrency API في Java؟

يتم استخدام واجهة java.util.concurrent.locks.Lock كآلية للمزامنة. إنه يعمل بشكل مشابه للكتلة المتزامنة. هناك بعض الاختلافات بين القفل والكتلة المتزامنة الموضحة أدناه.

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

41) شرح واجهة ExecutorService.

واجهة ExecutorService هي الواجهة الفرعية لواجهة Executor وتضيف ميزات لإدارة دورة الحياة. النظر في المثال التالي.

 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { ExecutorService e = Executors.newSingleThreadExecutor(); try { e.submit(new Thread()); System.out.println('Shutdown executor'); e.shutdown(); e.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException ex) { System.err.println('tasks interrupted'); } finally { if (!e.isTerminated()) { System.err.println('cancel non-finished tasks'); } e.shutdownNow(); System.out.println('shutdown finished'); } } static class Task implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 20); System.out.println('Running Task!'); TimeUnit.SECONDS.sleep(duration); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } 

انتاج |

 Shutdown executor shutdown finished 

42) ما هو الفرق بين البرمجة المتزامنة والبرمجة غير المتزامنة فيما يتعلق بالموضوع؟

البرمجة المتزامنة: في نموذج البرمجة المتزامنة، يتم تعيين خيط لإكمال مهمة ومن ثم يبدأ الخيط في العمل عليه، وهو متاح فقط للمهام الأخرى بمجرد انتهاء المهمة المعينة.

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

43) ماذا تفهم من Callable و Future في Java؟

واجهة جافا القابلة للاستدعاء: تم توفير الواجهة القابلة للاستدعاء في Java5 بواسطة الحزمة java.util.concurrent. إنها مشابهة للواجهة Runnable ولكنها يمكنها إرجاع نتيجة، ويمكنها طرح استثناء. كما يوفر أيضًا طريقة run() لتنفيذ سلسلة المحادثات. يمكن لـ Java Callable إرجاع أي كائن لأنه يستخدم Generic.

بناء الجملة:

متى خرج الفوز 7؟

واجهة عامة قابلة للاستدعاء

واجهة جافا المستقبلية: واجهة Java Future تعطي نتيجة لعملية متزامنة. تقوم الواجهة القابلة للاستدعاء بإرجاع كائن java.util.concurrent.Future.

يوفر Java Future الطرق التالية للتنفيذ.

إلغاء (منطقي mayInterruptIfRunning):يتم استخدامه لإلغاء تنفيذ المهمة المعينة.يحصل():ينتظر الوقت إذا لم يكتمل التنفيذ ثم يسترجع النتيجة.تم إلغاء():تقوم بإرجاع القيمة المنطقية كما ترجع صحيحًا إذا تم إلغاء المهمة قبل اكتمالها.تم():يُرجع صحيحًا إذا اكتملت المهمة بنجاح، وإلا يُرجع خطأ.

44. ما هو الفرق بينScheduledExecutorService وواجهة ExecutorService؟

يعد كل من ExecutorServcie وScheduledExecutorService واجهات لحزمة java.util.Concurrent ولكن جدولة ExecutorService توفر بعض الطرق الإضافية لتنفيذ المهام القابلة للتشغيل والقابلة للاستدعاء مع التأخير أو كل فترة زمنية محددة.

45) تحديد فئة FutureTask في جافا؟

توفر فئة Java FutureTask تطبيقًا أساسيًا للواجهة المستقبلية. لا يمكن الحصول على النتيجة إلا في حالة اكتمال تنفيذ مهمة واحدة، وإذا لم يتم تحقيق الحساب، فسيتم حظر طريقة get. إذا اكتمل التنفيذ، فلا يمكن إعادة تشغيله ولا يمكن إلغاؤه.

بناء الجملة

تقوم الطبقة العامة FutureTask بتوسيع الكائن بتنفيذ RunnableFuture