الخيوط ومجمّعات الخيوط والمنفّذات – المعالجة المتزامنة في Java
نظرة معمّقة على آلية عمل التطبيقات المختلفة لواجهة Executor في Java.
يُعدّ التزامن من أصعب المشكلات التي نتعامل معها نحن المطوّرين في عملنا اليومي. وهو في الوقت نفسه من أكثر المشكلات التي نصادفها أثناء تنفيذ المهام الروتينية. وهذا المزيج من الصعوبة وكثرة الحدوث هو ما يجعل التزامن وتعدد الخيوط من أخطر المجالات التي قد يدخلها مهندس البرمجيات.
علاوة على ذلك، فإن معالجة التزامن بتجريدات منخفضة المستوى قد تكون مرهقة ذهنيًا وتُنتج أخطاءً معقّدة غير حتمية. ولهذا السبب توفّر معظم اللغات تجريدات أعلى مستوى تتيح لنا حل المشكلات المتعلقة بالتزامن بسهولة نسبية، دون إضاعة الوقت في العبث بالمفاتيح منخفضة المستوى.
في هذا المقال أودّ أن أنظر عن كثب في أحد هذه التجريدات من المكتبة القياسية في Java: واجهة ExecutorService وتطبيقاتها. وأريد أيضًا أن يكون هذا المقال نقطة انطلاق لمقالي القادم حول قياس أداء تدفقات Java (Java streams).
لكن أولًا، تذكير موجز بالعمليات والخيوط
ما هي العملية؟
العملية هي أبسط وحدة يمكن لحواسيبنا تشغيلها بشكل مستقل. تتيح لنا العمليات تقسيم العمل الذي تنفّذه أجهزتنا إلى أجزاء أصغر وأكثر نمطية وأسهل إدارة.
وهذا يجعل كل جزء أكثر تركيزًا وبالتالي أسرع. كما يتيح هذا التقسيم الاستفادة الكاملة من الأنوية المتعددة المدمجة في معالجاتنا.
بصورة عامة، كل عملية هي نسخة من برنامج معيّن – فعملية Java قيد التشغيل مثلًا هي نسخة من برنامج JVM.
وفضلًا عن ذلك، تعيش كل عملية داخل نظام التشغيل ولها مجموعتها الخاصة من الموارد والصلاحيات والسلوك (شيفرة البرنامج) – تمامًا مثل مستخدمي تطبيقاتنا.
يمكن أن تحتوي العملية على عدة خيوط (في معظم أنظمة التشغيل على الأقل)، تتعاون لإنجاز المهام المشتركة التي تسندها إليها العملية.
ما هو الخيط؟
يمكنك تخيّل الخيط على أنه فرع من شيفرتنا له مجموعة التعليمات الخاصة به، ويعمل بالتوازي مع بقية أجزاء التطبيق. تتيح الخيوط للعملية الواحدة تنفيذ عدة تسلسلات من التعليمات بالتزامن.
على مستوى البرمجيات، يمكننا التمييز بين نوعين من الخيوط:
- خيوط النواة (خيوط النظام)
يتولى نظام التشغيل التعامل مع هذه الخيوط مباشرة. وتتم عمليات إنشائها وجدولتها وإدارتها بواسطة نواة نظام التشغيل. - خيوط التطبيق (خيوط المستخدم)
يجري التعامل مع هذه الخيوط على مستوى المستخدم بواسطة مكتبة خيوط أو بيئة تشغيل، بمعزل عن نظام التشغيل. ولا تستطيع نواة نظام التشغيل رؤيتها، لذا يعاملها نظام التشغيل كأنها عمليات أحادية الخيط.
في هذا المقال أركّز بشكل رئيسي على خيوط التطبيق. وسأتطرق أيضًا إلى الخيوط المرتبطة بالمعالج، أي خيوط العتاد، وهي خاصية من خصائص معالجاتنا. ويعكس عددها عدد الخيوط التي يستطيع معالجنا التعامل معها في الوقت نفسه.
من حيث المبدأ، تتشارك الخيوط الموارد بشكل أخف بكثير من العمليات. فكل خيط داخل عملية يمكنه الوصول إلى جميع البيانات التي تخص العملية الأم.
بالإضافة إلى ذلك، يمكن لكل خيط أن يحتفظ ببياناته الخاصة، وتُسمّى عادةً المتغيرات المحلية للخيط (Thread local variables) أو، في Java، ScopedValues الأحدث والمفضّلة. كما أن التبديل بين الخيوط أرخص بكثير من التبديل بين العمليات.
ما هو مجمّع الخيوط؟
مجمّع الخيوط (Thread Pool) مفهوم أكثر تحديدًا من الخيط أو العملية. وهو يتعلق بخيوط التطبيق ويشير إلى مجموعة من هذه الخيوط المتاحة للاستخدام داخل تطبيقنا.
سلوكه بسيط جدًا: نأخذ الخيوط من المجمّع واحدًا تلو الآخر حتى لا يتبقى أي خيط، وهذا كل شيء. غير أن هناك افتراضًا إضافيًا، وهو أن الخيوط تعود إلى المجمّع بعد إنهاء مهمتها.
وبطبيعة الحال، يمكن أن يحتوي التطبيق على عدة مجمّعات خيوط، وكلما كان كل مجمّع أكثر تخصصًا كان ذلك أفضل. فهذا النهج يقلل التنازع داخل التطبيق ويزيل نقاط الفشل الوحيدة. والمعيار الصناعي اليوم هو أن يكون هناك مجمّع خيوط مخصص على الأقل لاتصالات قاعدة البيانات.
الخيوط ومجمّعات الخيوط وJava
في إصدارات Java الأقدم – قبل Java 21 – كان كل خيط يُستخدم في التطبيق مرتبطًا بخيط معالج. ونتيجة لذلك كانت الخيوط مكلفة وثقيلة نسبيًا.
إذا أنشأت عن طريق الخطأ (أو عمدًا) عددًا كبيرًا جدًا من الخيوط في تطبيق Java، على سبيل المثال باستدعاء “new Thread()”، فيمكنك استنزاف الموارد بسرعة كبيرة، وسينخفض أداء تطبيقك بشدة – ويرجع ذلك جزئيًا إلى أن المعالج يضطر إلى إجراء قدر كبير جدًا من تبديل السياق.
جاء Project Loom، الذي صدر مع Java 21، لحل هذه المشكلة بإدخال الخيوط الافتراضية (virtual threads) – وهي خيوط غير مرتبطة بخيوط المعالج وتُعرف أيضًا بالخيوط الخضراء – إلى المكتبة القياسية في Java.
تطبّق Java مفهوم مجمّع الخيوط عبر ThreadPoolExecutor – وهو صنف يمثّل مجمّع خيوط محدود الحجم يُحدَّد حدّه الأعلى بالمعامل maximumPoolSize في مُنشئه.
وللعلم، يعمل هذا المنفّذ أيضًا بوصفه مجمّع الخيوط الداخلي في المنفّذات الأكثر تعقيدًا.
Executor وExecutorService وExecutors
قبل وصف التطبيقات الأكثر تقدمًا لواجهات Executor التي تعتمد على ThreadPoolExecutor، أودّ الإجابة عن سؤال آخر: ما هما بالضبط Executor وExecutorService؟
- Executor
Executor واجهة تحتوي على دالة واحدة فقط هي execute، وتوقيعهاvoid execute(Runnable command). تمثّل الواجهة عملية بسيطة جدًا – أو بدقة أكبر، تنص على أن الصنف المنفِّذ قادر على القيام بها: تشغيل Runnable معيّن. وهدفها فصل عملية إرسال المهمة عن تفاصيل كيفية تنفيذها. - ExecutorService
ExecutorService واجهة أخرى توسّع Executor. عقدها أغنى بكثير من عقد Executor، إذ تضم نحو 13 دالة يجب تجاوزها إذا اخترنا تنفيذها. وغايتها الرئيسية دعم إدارة وتشغيل المهام غير المتزامنة بتغليفها في Future من Java. كما توسّع ExecutorService الواجهة Autocloseable، ولذلك يمكننا استخدامها بصيغة try-with-resource وإغلاقها بشكل منظّم. - Executors
أما الصنف Executors فهو، على العكس، صنف مساعد. وهو الطريقة المفضلة لإنشاء نسخ جديدة من المنفّذات – إذ يُنصح بعدم استخدام الكلمة المفتاحية new مع معظم المنفّذات. كما يوفّر دوالّ لإنشاء أنواع مختلفة من نسخ callable، مثل callable يُرجع قيمة ثابتة.
بعد أن غطينا هذه المفاهيم الأساسية الثلاثة، يمكننا الآن النظر في مختلف تطبيقات خدمة المنفّذ.
خدمات المنفّذ
توفّر المكتبة القياسية في Java حاليًا 4 تطبيقات رئيسية لواجهة ExecutorService، لكل منها مجموعة من الميزات المميّزة بدرجات متفاوتة.
وهي كما يلي:
- ThreadPoolExecutor
- ForkJoinPool
- ScheduledThreadPoolExecutor
- ThreadPerTaskExecutor
إضافة إلى ذلك، يحتوي Executors.class على ثلاثة تطبيقات ثابتة خاصة (private static) لـ ExecutorService:
- DelegatedExecutorService
- DelegatedScheduledExecutorService
- AutoShutdownDelegatedExecutorService
وإجمالًا، تبدو العلاقات بين هذه الأصناف تقريبًا على النحو التالي.

ThreadPoolExecutor
كما ذُكر سابقًا، هذا هو تطبيق Java لمفهوم مجمّع الخيوط. يمثّل المنفّذ مجمّع خيوط محدودًا بعدد متغيّر من الخيوط. وعمليًا يعني هذا أن TheadPoolExecutor يعمل بعدد محدود من الخيوط، ولا يمكن لهذا العدد أن يتجاوز الحد المحدد عند إنشاء المجمّع.
ولهذا الغرض يعتمد ThreadPoolExecutor على متغيّرين هما corePoolSize وmaximumPoolSize. يحدّد الأول، corePoolSize، الحد الأدنى لعدد الخيوط في المجمّع – إذ يُبقيها المجمّع حيّة حتى عندما تكون خاملة.
ويحدّد الثاني، maximumPoolSize، كما خمّنتَ على الأرجح، أكبر عدد من الخيوط يجوز للمجمّع امتلاكه. وهو الحد الأعلى للخيوط داخل المجمّع، ولن يتجاوز المجمّع قيمة هذا المعامل أبدًا.
كما يستخدم ThreadPoolExecutor قائمة انتظار BlockingQueue في الخلفية لتتبع المهام الواردة.
كيف يتصرف ThreadPoolExecutor
افتراضيًا، عندما يكون عدد الخيوط العاملة حاليًا أقل من corePoolSize، فإن استدعاء دالة execute ينشئ خيطًا جديدًا ويسلّمه المهمة الواردة بوصفها أول مهمة له – حتى لو كانت بعض الخيوط في المجمّع خاملة. وإذا تعذّر على المجمّع إضافة خيط جديد لأي سبب، فإنه يلجأ إلى السلوك الثاني.
وعندما يكون عدد الخيوط العاملة مساويًا لـ corePoolSize أو أكبر منه، أو عندما فشل المجمّع في إنشاء خيط جديد، فإن استدعاء execute يؤدي إلى محاولة وضع المهمة الجديدة في قائمة الانتظار.
isRunning(c) && workQueue.offer(command)
إذا كان المجمّع لا يزال يعمل، تُضاف إليه خيط جديد دون مهمة أولى – وهي الحالة الوحيدة التي يُنشأ فيها خيط بلا أي مهمة.
addWorker(null, false);
أما إذا لم يعد المجمّع يعمل، فتُزال الأوامر الجديدة من القائمة
!isRunning(recheck) && remove(command)
ثم يرفض المجمّع الأمر مع إطلاق RejectedExecutionException
reject(command);
وإذا تعذّرت إضافة المهمة إلى القائمة لسبب ما، يحاول المجمّع بدء خيط جديد بهذه المهمة بوصفها مهمته الأولى.
else if (!addWorker(command, false))
وإذا فشل ذلك أيضًا، تُرفض المهمة ويُطلق RejectedExecutionException مع رسالة على غرار ما يلي.
الرسالة: Task X rejected from java.util.concurrent.ThreadPoolExecutor@3a71f4dd[Running, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]

تُظهر الصورة أعلاه عرضًا مبسّطًا جدًا للحالة الداخلية لـ ThreadPoolExecutor. ومن هذه النقطة قد يحدث أحد أمرين: إما أن تنتهي معالجة Task4 (أو Task5) قبل إرسال Task6 إلى المجمّع، أو أن يُرسَل Task6 قبل أن تنتهي Task4 (أو Task5).
الحالة الأولى مملة إلى حد ما، إذ لا يتغير شيء من وجهة نظر المنفّذ، ولذلك لن أتوقف عندها.
أما الحالة الثانية فهي أكثر إثارة للاهتمام بكثير لأنها تغيّر حالة المنفّذ. فبما أن عدد الخيوط العاملة أقل من corePoolSize، فإن إرسال Task6 إلى المنفّذ يؤدي إلى إنشاء عامل جديد له. وستبدو الحالة الناتجة تقريبًا كما يلي.

حجم مجمّع ThreadPoolExecutor
- مجمّع ثابت الحجم
إعطاء corePoolSize وmaximumPoolSize القيمة نفسها ينتج عمليًا مجمّع خيوط ثابت الحجم: لن ينخفض عدد الخيوط التي يشغّلها المجمّع عن هذه القيمة ولن يرتفع عنها – على الأقل ليس لفترة طويلة. - مجمّع غير محدود
ضبط maximumPoolSize على قيمة كبيرة بما يكفي، مثل Integer.MAX_VALUE، يجعل المجمّع غير محدود عمليًا. صحيح أن تطبيق ThreadPoolExecutor يفرض سقفًا عمليًا يبلغ نحو 500 مليون ((2^29)-1) خيط، لكنني أراهن على أن جهازك سينهار قبل أن تبلغه بوقت طويل.
إذا أردت أن تفهم لماذا هذا الرقم تحديدًا هو الحد، فهناك JavaDoc ممتاز يشرح ذلك، وهو موضوع مباشرة بعد تصريح الصنف ThreadPoolExecutor. وكتلميح: الأمر يتعلق بكيفية تخزين ThreadPoolExecutor لحالته.
إنشاء ThreadPoolExecutor
يقدّم الصنف Executors 6 دوالّ في المجموع لإنشاء ThreadPoolExecutor. وسأستعرضها في أزواج، لأن هذه هي الطريقة التي صُمّمت لاستخدامها.
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
تُنتج هاتان الدالتان مجمّع خيوط ثابت الحجم يتساوى فيه الحجمان الأساسي والأقصى. ويمكنك أيضًا تمرير threadFactory كمعامل إذا كنت لا تفضّل الاعتماد على الافتراضي في المكتبة القياسية.
Executors.newFixedThreadPool(2);
Executors.newFixedThreadPool(2, Executors.defaultThreadFactory());
الزوج التالي من الدوالّ:
public static ExecutorService newCachedThreadPool()
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)
تُنتج هاتان الدالتان مجمّعات خيوط غير محدودة عمليًا، لأن maxPollSize تُضبط على Integer.Max؛ وكما في FixThreadPool، تتيح النسخة الثانية تمرير ThreadFactory مخصص.
Executors.newCachedThreadPool();
Executors.newCachedThreadPool(Executors.defaultThreadFactory());
والزوج الأخير:
public static ExecutorService newSingleThreadExecutor()
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)
تُنتج كلتاهما مجمّع خيوط يعتمد على خيط واحد. علاوة على ذلك، فإنهما تنشئان ThreadPoolExecutor مغلّفًا في AutoShutdownDelegatedExecutorService، الذي لا يكشف سوى دوالّ ExecutorService – ولا يمكن الوصول إلى أي من الدوالّ الخاصة بـ ThreadPoolExecutor.
وإضافة إلى ذلك، يُعاد تعريف دالة shutdown باستخدام Cleanable، وتُستدعى بمجرد أن يصبح الكائن Phantom reachable، أي قابلًا للوصول شبحيًا.
إرسال مهام جديدة إلى ThreadPoolExecutor
الطريقة القياسية لتسليم مهام جديدة إلى ThreadPoolExecutor هي عبر إحدى صيغ دالة submit. وبدلًا من ذلك يمكنك استدعاء دالة execute من واجهة Executor مباشرة، مع أن ذلك ليس النهج الموصى به.
تُرجع دالة execute القيمة void بدلًا من Future، مما يمنحك تحكمًا أقل في تنفيذ المهمة – والقرار لك. وفي كلتا الحالتين، تمر الطريقتان عبر كل منطق مجمّع الخيوط الموصوف أعلاه.
Runnable task = () -> System.out.print("test");
Future<?> submit = executorService.submit(task);
مقابل
executorService.execute(task);
ForkJoinPool
ForkJoinPool تطبيق مستقل تمامًا لـ ExecutorService، وميزته الأساسية هي سرقة العمل (work-stealing).
سرقة العمل فكرة معقدة إلى حد ما وتستحق مقالة مدونة خاصة بها. ومع ذلك، على مستوى تجريد مرتفع بما يكفي، يمكن شرحها ببساطة: يحاول كل خيط في المجمّع تنفيذ أي مهمة أُرسلت إلى المجمّع، بغض النظر عن الخيط الذي كان يملكها في الأصل.
ومن هنا جاء اسم سرقة العمل – فالخيوط “تسرق” العمل من بعضها. ومن الناحية النظرية ينبغي أن يحقق ذلك تحسينات ملحوظة في الأداء، خاصة عندما تكون المهام المرسلة صغيرة أو تُنشئ مهامّ فرعية أخرى.
أخطط لنشر مقال مخصص حول سرقة العمل وإطار ForkJoinFramework في المستقبل القريب (Future). وفي الأثناء، يمكنك معرفة المزيد عن سرقة العمل هنا.
كيف يتصرف ForkJoinPool
ينتمي هذا المنفّذ إلى إطار ForkJoin في Java، الذي أُدخل في Java 7 – وهو مجموعة من الأصناف تهدف إلى جعل معالجة المهام المتوازية أكثر كفاءة عبر سرقة العمل. واليوم يُستخدم هذا الإطار بكثافة في سياق CompletableFuture وStreams.
للحصول على أقصى فائدة من ForkJoinPool، أقترح تعلّم إطار ForkJoin ككل ثم تكييف طريقة تعاملك مع هذه المهام بحيث تلائم متطلبات ForkJoin بشكل أفضل.
قبل الغوص مباشرة في إطار ForkJoin، شغّل اختبارات قياس الأداء واختبارات الأداء، لأن المكاسب الفعلية قد تكون أقل من المتوقع.
كما تتضمن وثائق Java الخاصة بـ ForkJoinPool جدولًا يسرد الدوالّ التي ينبغي استخدامها عند التعامل مع ForkJoinPool للحصول على أفضل النتائج.
المعامل الأساسي لـ ForkJoinPool هو parallelism، الذي يحدد عدد الخيوط العاملة التي يستخدمها المجمّع. وافتراضيًا يساوي عدد المعالجات المتاحة في معالجك. وهذا إعداد مناسب على الأقل في معظم الحالات، وأنصح بعدم تغييره دون اختبارات أداء مناسبة.
وتذكّر أن خيوط Java مقيّدة بالمعالج (CPU bound)، لذا يمكننا استنزاف قدرة المعالجة اللازمة لإحراز تقدم في مهامنا بسرعة.
إنشاء نسخ ForkJoinPool
يقدّم الصنف Executors دالتين لإنشاء نسخ ForkJoinPool
Executors.newWorkStealingPool();
Executors.newWorkStealingPool(2);
تنشئ الأولى forkJoinPoll بدرجة التوازي الافتراضية، أي عدد المعالجات المتاحة، بينما تتيح لنا الثانية اختيار مستوى التوازي بأنفسنا.
وعلاوة على ذلك، تنشئ Executors ForkJoinPool مدعومًا بقائمة انتظار FIFO، بينما الافتراضي في ForkJoinPool نفسه (مثلًا عبر new ForkJoinPool(2)) هو LIFO. ولا يمكن استخدام LIFO مع Executors. ومع ذلك يمكنك تغيير نوع القائمة الأساسية عبر معامل المُنشئ asyncMode في الصنف ForkJoinPool.
مع إعداد FIFO، قد يكون ForkJoinPool أنسب للمهام التي لا تُنفَّذ لها عملية join أبدًا – مثلًا عند استخدامه مع callable أو runnable.
ScheduledThreadPoolExecutor
يبني ScheduledThreadPoolExecutor طبقة فوق ThreadPoolExecutor الكلاسيكي تتيح جدولة المهام.
وهو يوفّر ثلاثة أنواع من الجدولة:
- التشغيل مرة واحدة بعد تأخير ثابت – schedule
- التشغيل كل عدد معيّن من وحدات الزمن – scheduleAtFixedRate
- التشغيل مع تأخير ثابت بين كل تنفيذ وآخر – scheduleWithFixedDelay
وبالطبع تتوفر أيضًا واجهة ExecutorService “العادية”. فقط تذكّر أن دالتي submit وexecute هنا مكافئتان لاستدعاء schedule بتأخير 0 – أي أن المهمة المعطاة تعمل فورًا.
وبما أن ScheduledThreadPoolExecutor يوسّع ThreadPoolExecutor، فإن أجزاء من تطبيقه تتطابق مع ThreadPoolExecutor الكلاسيكي. غير أنه يعتمد على تطبيقه الخاص للمهام، ScheduledFutureTask، وقائمة الانتظار الخاصة به، DelayedWorkQueue.
وإضافة إلى ذلك، يستخدم ScheduledThreadPoolExecutor دائمًا ThreadPoolExecutor ثابت الحجم بوصفه مجمّع الخيوط الأساسي، مما يعني أن corePoolSize وMaxPoolSize متساويان دائمًا.
ومع ذلك، فإن تطبيق ScheduledThreadPoolExecutor يخفي مأزقًا أو اثنين.
- أولًا، عندما تُجدول مهمتان (أو ينتهي بهما الأمر مجدولتين) للّحظة نفسها، فإنهما تعملان بترتيب FIFO بحسب وقت الإرسال.
- المأزق الثاني ينتج منطقيًا عن الأول: لا شيء يضمن حقًا أن مهمة معيّنة ستعمل في لحظة محددة – فقد تكون عالقة، على سبيل المثال، في الانتظار داخل القائمة الموصوفة في النقطة السابقة.
- وأخيرًا، إذا تداخل تنفيذ مهمتين لسبب ما، فإن مجمّع الخيوط يضمن أن تنفيذ الأولى “يحدث قبل” الثانية اللاحقة. أي أن ترتيب FIFO ينطبق، حتى على المهام المرسلة من خيوط مختلفة.
إنشاء ScheduledThreadPoolExecutor
يقدّم الصنف Executors خمس طرق لإنشاء ScheduledThreadPoolExecutor، مجمّعة بشكل مشابه لتلك الخاصة بـ ThreadPoolExecutor.
ScheduledThreadPoolExecutor بعدد ثابت من الخيوط:
Executors.newScheduledThreadPool(2);
Executors.newScheduledThreadPool(2, Executors.defaultThreadFactory());
تنشئ الدالة الأولى ScheduledThreadPoolExecutor بعدد معيّن من الخيوط، وتتيح لنا الثانية بالإضافة إلى ذلك تمرير ThreadFactory من اختيارنا.
ScheduledThreadPoolExecutor بخيط واحد:
Executors.newSingleThreadScheduledExecutor();
Executors.newSingleThreadScheduledExecutor(Executors.defaultThreadFactory());
تنشئ هاتان الدالتان SingleThreadScheduledExecutor يحتوي ThreadExecutorPool الأساسي فيه على خيط واحد فقط. وما نحصل عليه فعليًا هو نسخة من DelegatedScheduledExecutorService تفوّض إلى ScheduledThreadPoolExecutor، وبالتالي فإن ThreadExecutorPool الأساسي لدى المفوَّض يحتوي في النهاية على خيط واحد.
والطريقة الأخيرة لإنشاء ScheduledThreadPoolExecutor هي عبر:
Executors.unconfigurableScheduledExecutorService(new DummyScheduledExecutorServiceImpl());
تغلّف هذه الدالة تطبيقك الخاص لواجهة ScheduledExecutorService في DelegatedScheduledExecutorService – أحد الأصناف الثابتة الخاصة داخل Executors – الذي لا يكشف سوى دوالّ واجهة ScheduledExecutorService.
ويمكن اعتبارها، بمعنى ما، أداة مساعدة للتغليف: فقد يحتوي تطبيقك على العديد من الدوالّ العامة، لكن بمجرد تغليفه بالمفوِّض تُخفى جميعها عن المستخدمين.
لست من المعجبين حقًا بهذا النهج في التغليف – فهذا ينبغي أن يكون من شأن التطبيق نفسه. ومع ذلك، ربما أغفل حالة استخدام مهمة أخرى لهذه المفوِّضات.
ThreadPerTaskExecutor
هذه إحدى أحدث الإضافات إلى المكتبة القياسية في Java وإلى الصنف Executors. فهو ليس تطبيقًا لمجمّع خيوط، بل مُولِّد خيوط. وكما يشير اسمه، تحصل كل مهمة مرسلة على خيطها الخاص المرتبط بتنفيذها، ويبدأ هذا الخيط عند بدء معالجة المهمة.
ولتحقيق ذلك، يستخدم المنفّذ تطبيقه المخصص لـ Future، وهو ThreadBoundFuture. وتبدو دورة حياة الخيوط التي تنشئها هذه المنفّذات تقريبًا كما يلي:
- يُنشأ الخيط في اللحظة نفسها التي يُنشأ فيها Future،
- لا يبدأ الخيط العمل إلا عندما يبدأه المنفّذ برمجيًا
- يُقاطَع الخيط كلما قوطع Future
- يتوقف الخيط عندما يكتمل Future
وبالإضافة إلى ذلك، عندما لا يستطيع المنفّذ بدء خيط جديد لمهمة معيّنة ولا يحدث أي استثناء في أثناء ذلك، فإن المنفّذ سيطلق RejectedExecutionException.
كما يحتفظ ThreadPerTaskExecutor بمجموعة من الخيوط العاملة (up- threads). في كل مرة يبدأ فيها خيط يُضاف إلى المجموعة، وفي كل مرة يتوقف فيها خيط يُزال منها.
ومن خلال دالة threadCount()، يمكنك استخدام هذه المجموعة للتحقق من عدد الخيوط التي يشغّلها المنفّذ في أي لحظة.
إنشاء ThreadPerTaskExecutor
يقدّم الصنف Executors طريقتين لإنشاء هذا المنفّذ، وفي رأيي إحداهما أفضل من الأخرى. لنبدأ بالتي لا أوصي بها.
Executors.newThreadPerTaskExecutor(Executors.defaultThreadFactory());
تنشئ هذه الدالة ThreadPerTaskExecutor باستخدام مصنع الخيوط المعطى. والسبب الذي يجعلني، على الأقل، أنصح بعدم استخدامها هو أن نسخة ThreadPerTaskExecutor هذه تعمل على خيوط Java القديمة العادية المقيّدة بالمعالج.
في هذه الحالة، يمكن لدفع عدد كبير بما يكفي من المهام عبر المنفّذ أن يستنزف قدرة المعالجة في تطبيقك بسهولة بالغة.
صحيح أنه لا شيء يمنعك من تنفيذ “الحيلة” التالية واستخدام الخيوط الافتراضية على أي حال.
Executors.newThreadPerTaskExecutor(Thread.ofVirtual().factory());
لكن لا جدوى من ذلك عندما يمكنك ببساطة استخدام هذا بدلًا منه.
Executors.newVirtualThreadPerTaskExecutor();
تستفيد نسخة ThreadPerTaskExecutor هذه استفادة كاملة من الخيوط الافتراضية في Java 21. كما ينبغي أن يرفع هذا الإعداد بشكل كبير عدد المهام التي يستطيع منفّذك التعامل معها قبل أن تنفد قدرة المعالجة.
الخلاصة
كما رأينا أعلاه، توفّر Java مجموعة من المنفّذات، من تطبيق مجمّع الخيوط الكلاسيكي في ThreadPoolExecutor إلى منفّذات أكثر تطورًا مثل ThreadPerTaskExecutor، الذي يستغل الخيوط الافتراضية استغلالًا كاملًا، وهي ميزة من Java 21.
وعلاوة على ذلك، لكل تطبيق من تطبيقات Executor خاصيته المميّزة.
- ThreadPoolExecutor – تطبيق مجمّع الخيوط الكلاسيكي
- ForkJoinPool – سرقة العمل
- ScheduledThreadPoolExecutor – جدولة المهام الدورية
- ThreadPerTaskExecutor – استخدام الخيوط الافتراضية والقدرة على تشغيل كل مهمة في خيطها القصير العمر الخاص.
وعلى الرغم من هذه الاختلافات، تشترك جميع المنفّذات في خاصية أساسية واحدة: كل منها يوفّر واجهة برمجية تجعل معالجة عدد كبير من المهام بالتزامن أبسط بكثير.
آمل أن تكون هذه المعرفة مفيدة لك في وقت ما في المستقبل. شكرًا على القراءة.