تقدير المشروع
← كل المقالات

ماذا يعني الحجب (blocking) في Loom؟

يجلب Project Loom الخيوط الافتراضية (Virtual Threads) إلى بيئة تشغيل Java، ويصدر ضمن JDK 21. ولبلوغ أهداف الأداء، تتولى بيئة تشغيل Loom معالجة عمليات الحجب.

15 دقائق قراءة
JavaProject LoomالتزامنJVMتعدد الخيوطالخيوط الافتراضية

يجلب Project Loom فكرة الخيوط الافتراضية (Virtual Threads) إلى بيئة تشغيل Java، وفي سبتمبر سيصدر ميزة مستقرة ضمن JDK 21. هدف Project Loom الجمع بين مزايا الأداء في البرمجة غير المتزامنة وسهولة أسلوب كتابة الشيفرة المباشر “المتزامن”.

ولبلوغ أهداف الأداء هذه، يجب أن تعامل بيئة تشغيل Loom كل عملية حجب معاملة خاصة. لنتعرف على كيفية عمل هذه المعاملة الخاصة وما إذا كانت البرمجة مع Loom تنطوي على حالات حدّية.

قبل أن نبدأ، يجدر توضيح معنى الحجب (blocking) هنا: هي حالة من حالات خيط البرنامج لا يؤدي فيها الخيط عملاً مفيداً (لا يستخدم المعالج) بل ينتظر تحقق شرط خارجي ما. ومن الأمثلة النموذجية الانتظار على semaphore أو انتظار وصول بيانات إلى socket.

الخيوط الحاملة والخيوط الافتراضية

للبدء، إليك نظرة موجزة على المفاهيم الرئيسية في Loom. في الأساس توجد خيوط المنصة (platform threads)، وتسمى أيضاً خيوط النواة (kernel threads). تملك Java هذه الخيوط منذ زمن طويل؛ وحتى الآن كانت كل نسخة Thread قيد التشغيل تقابل خيط نواة واحداً بالضبط. هذه الخيوط ثقيلة، وإنشاؤها والتبديل بينها مكلفان. وهي مورد محدود يجب إدارته بعناية، مثلاً عبر مجمّع خيوط (thread pool).

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

في الخلفية، تحتفظ بيئة تشغيل JVM+Loom بمجمّع من خيوط المنصة، يُعرف باسم الخيوط الحاملة (carrier threads)، تُوزَّع عليه الخيوط الافتراضية (multiplexing). بعبارة أخرى، تنفذ حفنة من خيوط المنصة عدداً كبيراً من الخيوط الافتراضية. وفي كل مرة يستدعي فيها خيط افتراضي عملية حجب، ينبغي “وضعه جانباً” إلى أن يتحقق الشرط الذي ينتظره، ليتمكن خيط افتراضي آخر من العمل على الخيط الحامل الذي تحرر للتو.

هذه الفكرة ليست جديدة: فقد نفذتها مكتبات تفاعلية (reactive) متنوعة باستخدام مجمّعات الخيوط وعمليات الإدخال والإخراج غير الحاجبة. لكنها هنا تحدث على مستوى بيئة التشغيل لا على مستوى مكتبة، ما يمنحنا صياغة أنظف بكثير وتتبعات مكدس (stack traces) ذات معنى، ويعفينا من العدوى التي تسببها أشياء مثل الغلاف Future.

هذا هو حدّنا في مقدمة Loom؛ ولاستكشاف أعمق أوصي بـ The Ultimate guide to Virtual Threads على مدونة Rock the JVM.

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

كل هذا يفترض أن كل عملية حجب تحرر الخيط الحامل ليحل محله خيط افتراضي آخر. لكن هل هذا ما يحدث فعلاً؟

تحديث عمليات الحجب (Retrofitting)

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

مثلاً، عندما تحجب الشيفرة على semaphore أو قفل (lock) أو أي بنية تزامن أخرى في Java، لا يُحجب الخيط الحامل الكامن. بل تُرسَل إشارة إلى بيئة التشغيل لالتقاط الاستمرارية (continuation) للخيط الافتراضي الحالي ووضعها في طابور انتظار واستئنافها بعد حل الشرط الذي سبّب الحجب.

وبالمثل، لم تعد Thread.sleep تحجب سوى الخيط الافتراضي وتترك الخيط الحامل حراً. ونتيجة لذلك تنتهي الشيفرة التالية في 4 ثوانٍ، رغم أنه لم يُشغَّل سوى نحو 15 خيط منصة (يعتمد حجم مجمّع الخيوط الحاملة الذي يشغّل الخيوط الافتراضية على عدد الأنوية المتاحة لـ JVM):

var e = Executors.newVirtualThreadPerTaskExecutor();
for (int i = 0; i < 1000; i++) {
    e.submit(() -> { sleep(4000); });
}
e.shutdown();
e.awaitTermination(1, TimeUnit.DAYS);

مشكلات المزامنة

لكن ليست كل بنية في Java قد خضعت لهذا التحديث. ومن بين ما لم يخضع له الدوال وكتل الشيفرة synchronized. عند استخدامها يصبح الخيط الافتراضي مثبّتاً (pinned) على خيطه الحامل. وما دام الخيط مثبّتاً، تحجب أي عملية حجب الخيط الحامل الكامن – تماماً كما كان الحال قبل Loom.

تأمل هذا المثال:

var e = Executors.newVirtualThreadPerTaskExecutor();
for (int i = 0; i < 1000; i++) {
    e.submit(() -> { new Test().test(); });
}
e.shutdown();
e.awaitTermination(1, TimeUnit.DAYS);

class Test {
    synchronized void test() {
        sleep(4000);
    }
}

لاحظ أن كل مهمة مُرسَلة تنشئ Test جديدة، لذا يُستخدم monitor مختلف لكل استدعاء للدالة synchronized void test(). ومع ذلك، بما أننا نعتمد على synchronized، يتثبّت الخيط على الخيط الحامل. ومع 5 خيوط في مجمّع الحاملات، لا يمكن تشغيل سوى خمس مهام في آن واحد (لأنها تحجب المجمّع كله). ونتيجة لذلك، ورغم أن هذه الشيفرة تختلف قليلاً فقط عن المثال السابق، فإنها تحتاج إلى 1000/5*4 = 800 ثانية لتنتهي.

الحل هو استبدال الكلمة المفتاحية synchronized بأقفال (locks):

var e = Executors.newVirtualThreadPerTaskExecutor();
for (int i = 0; i < 1000; i++) {
    e.submit(() -> { new Test().test(); });
}
e.shutdown();
e.awaitTermination(1, TimeUnit.DAYS);

class Test {
    private ReentrantLock lock = new ReentrantLock();
    void test() {
        lock.tryLock();
        try {
            sleep(4000);
        } finally {
            lock.unlock();
        }
    }
}

مع Loom تنتهي هذه الشيفرة مجدداً في 4 ثوانٍ.

استبدال كتل synchronized بأقفال داخل JDK (حيثما أمكن) جزء آخر من نطاق Project Loom وممّا يصدر في JDK 21. وقد أجرت مكتبات Java وJVM متنوعة هذا النوع من التغييرات أو تجريه حالياً (مثل برامج تشغيل JDBC). أما شيفرة التطبيقات التي تعتمد على synchronized فستتطلب عناية إضافية.

Sockets

هل هناك مجالات أخرى، مثل synchronized، تؤدي إلى تثبيت الخيوط وقد تضر بأداء تطبيقنا؟

لحسن الحظ، فإن أحد أكثر مصادر الإدخال والإخراج انتشاراً – الاتصال الشبكي عبر TCP sockets – واعٍ بـ Loom بالكامل. وهذا غير مستغرب: إذ يمكن التعامل مع sockets بطريقة غير حاجبة (إما غير حاجبة كلياً أو بخيط “مدير” واحد ينسق تنفيذ كثير من مهام الإدخال والإخراج) عبر آليات مثل select() أو epoll().

هذا بالضبط ما يعتمد عليه Project Loom داخلياً لتقديم تنفيذ socket ينسجم جيداً مع الخيوط الافتراضية. تبقى تفاصيل الإدخال والإخراج غير الحاجب مخفية، ونعمل بواجهة متزامنة مألوفة. إن مثالاً كاملاً يستخدم java.net.Socket مباشرة سيكون طويلاً جداً، فتخيّل مثالاً يرسل عدة طلبات بالتزامن إلى خادم يرد بعد 3 ثوانٍ.

عند التدقيق ستلاحظ استدعاءات InputStream.read ملفوفة داخل BufferedReader يقرأ من مدخل الـ socket. هذا هو الاستدعاء الحاجب الذي يعلّق الخيط الافتراضي. مع Loom ينتهي الاختبار في 3 ثوانٍ، مع أنه لم يُشغَّل في JVM كله سوى 16 خيط منصة و50 طلباً تعمل بالتزامن.

غير أن الصورة تتغير بالنسبة إلى datagram sockets (التي تستخدم بروتوكول UDP). مرة أخرى لدينا خادم يرد بحزمة UDP بعد 3 ثوانٍ، لكن عند تشغيل العميل ستجد أن DatagramSocket.receive تثبّت الخيط، فلا يستطيع التقدم في أي لحظة سوى عدد قليل من العملاء (على الأكثر بعدد حجم مجمّع الخيوط الحاملة). ونتيجة لذلك يستغرق الاختبار كله وقتاً أطول.

حتى الآن حددنا سببين على الأقل لتثبيت الخيوط: كتل synchronized وdatagram sockets. فهل هناك أسباب أخرى؟

الملفات وDNS

نعم، فهناك واجهات برمجية أخرى تثبّت الخيوط وتحجب الخيط الحامل، وهي تحديداً كل عملية على الملفات (القراءة من FileInputStream والكتابة إلى ملف وسرد المجلدات وغيرها)، إضافة إلى تحويل أسماء النطاقات إلى عناوين IP باستخدام InetSocketAddress.

قد يبدو هذا مقلقاً، لكن Loom يطبّق بعض الإجراءات المضادة. فإذا نظرت في الشيفرة المصدرية لـ FileInputStream أو InetSocketAddress أو DatagramSocket فستلاحظ استخدامات للفئة jdk.internal.misc.Blocker. تلف استدعاءات الدالتين begin()/end() فيها كل استدعاء يحجب الخيط الحامل.

يشرح JavaDoc الخاص بها الغرض منها:

/**
 * Defines static methods to mark the beginning and end of a possibly blocking
 * operation. The methods are intended to be used with try-finally as follows:
 * {@snippet lang=java :
 *  long comp = Blocker.begin();
 *  try {
 *    // blocking operation
 *  } finally {
 *    Blocker.end(comp);
 *  }
 * }
 * If invoked from a virtual thread and the underlying carrier thread is a
 * CarrierThread then the code in the block runs as if it were in run in
 * ForkJoinPool.ManagedBlocker. This means the pool can be expanded to support
 * additional parallelism during the blocking operation.
 */
public class Blocker

بعبارة أخرى، عند وقوع عملية حجب، قد يُوسَّع مجمّع الخيوط الحاملة للتعويض عن تثبيت الخيط الناتج. ويمكن بدء خيط حامل جديد قادر على تشغيل الخيوط الافتراضية.

ملاحظة جانبية: التحقق من الأماكن التي تُستخدم فيها الفئة Blocker طريقة مفيدة أيضاً لمعرفة الواجهات التي تثبّت الخيوط في إصدار JDK معين.

اكتشاف الخيوط المثبّتة وإعداد مجمّع الحاملات

إذا كان تثبيت الخيوط يقلقك فأنت في صحبة جيدة – فهو بالتأكيد أمر يستحق المراقبة. ولحسن الحظ، يستطيع JVM الإبلاغ عن كل حالة منه عند تمرير الخيار -Djdk.tracePinnedThreads=short (وهناك أيضاً خيار full يطبع تتبع المكدس الكامل).

وينتج هذا رسائل مثل:

Thread[#91,ForkJoinPool-1-worker-7,5,CarrierThreads]
    java.base/sun.nio.ch.DatagramSocketAdaptor.receive(DatagramSocketAdaptor.java:241) <== monitors:1

إضافة إلى ذلك، يمكن ضبط الحجم الأولي والأقصى لمجمّع الخيوط الحاملة بخيارات الإعداد jdk.virtualThreadScheduler.parallelism وjdk.virtualThreadScheduler.maxPoolSize وjdk.virtualThreadScheduler.minRunnable. وهي تقابل مباشرة معاملات مُنشئ ForkJoinPool.

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

هل الحجب قدرنا؟

إلى حد ما، نعم – فبعض العمليات حاجبة بطبيعتها بسبب الطريقة التي بُنيت بها أنظمة التشغيل لدينا.

خذ أخطاء الصفحات (page faults): إذا وصل تطبيقنا إلى ذاكرة نُقلت إلى القرص (swapped out)، يقع page fault. وعلى نظام التشغيل تحميل محتوى الذاكرة من القرص قبل أن يتمكن تطبيقنا من المتابعة. وأثناء هذا التحميل يُحجب الخيط الذي لمس الصفحة. لا رأي لـ JVM ولا لأي بيئة تشغيل أخرى في ذلك. فإدارة الذاكرة منخفضة المستوى هذه من اختصاص النواة بالكامل وهي غير مرئية للتطبيق تماماً. لذا لا يمكننا أبداً إزالة الحجب كلياً، حتى لو اقتصر على شكل page faults.

ثم ماذا عن الملفات؟ من وجهة نظر النواة، يمكن للقراءة من socket أن تحجب، لأن الـ socket قد لا تحتوي بيانات بعد (قد لا تكون “جاهزة”). وقد تعني القراءة من socket انتظار وصول البيانات عبر الشبكة. أما الملفات فحالة مختلفة، إذ تُقرأ من أجهزة كتلية (block devices) متاحة محلياً. البيانات موجودة دائماً؛ وكل ما في الأمر أنه قد يلزم نسخها من القرص إلى الذاكرة.

بمعنى ما، وبقدر ما تعني النواة، فإن عمليات الملفات لا تحجب أبداً بالطريقة التي تحجب بها عمليات sockets. فقراءة ملف تشبه page fault إلى حد ما. ولهذا السبب فإن كل واجهة برمجية في النواة للوصول إلى الملفات هي في النهاية حاجبة (بالمعنى المحدد في البداية).

أما select، التي عالجت مشكلات sockets لدينا، فلا فائدة منها مع واصفات الملفات المحلية: إذ يُبلَّغ عنها بأنها “جاهزة” فوراً. ولا يمكن استخدام epoll/aio مع الملفات المحلية على الإطلاق. ولا تستطيع Java ولا أي بيئة تشغيل أخرى تحويل هذه الاستدعاءات إلى غير حاجبة.

هل ينقذ io_uring الموقف؟

لعلك صادفت io_uring: إضافة حديثة إلى النواة صُممت خصيصاً لتقديم واجهة برمجية غير متزامنة موحدة لكل أنواع عمليات الإدخال والإخراج، وفي مقدمتها العمليات على الملفات المحلية. ألا يستطيع Loom الاستفادة منها؟

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

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

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

هل نريد واجهة موحدة للإدخال والإخراج؟

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

بما أن لنوعي عمليات الإدخال والإخراج خصائص مختلفة، فهل الواجهة الموحدة معقولة؟ أليست تجريداً متسرباً (leaky abstraction)؟

بدأ Daniel Spiewak نقاشاً شيقاً على الإنترنت حول هذا الموضوع تحديداً. حجة Daniel أنه بما أن الملفات وsockets تحجب بطريقتين مختلفتين، فإن هذا الاختلاف لا ينبغي إخفاؤه خلف طبقة تجريد مثل io_uring أو الخيوط الافتراضية في Loom، بل إظهاره للمطور. والسبب أنه ينبغي استخدامهما بأنماط مختلفة، وينبغي تجميع كل استدعاء حاجب في دفعات وحراسته ببوابة، مثل semaphore أو طابور.

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

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

كم من التحكم نريد؟

يلاحظ Daniel أيضاً عن حق أن التمييز بين الحاجب وغير الحاجب لا يهم فعلاً إلا تحت الحمل العالي – لكن ذلك قد يكون هو المقياس نفسه الذي تهم عنده البرمجة غير المتزامنة أو Loom/io_uring أصلاً. وعند هذا المقياس قد ترغب في معرفة ما ينطوي عليه استدعاء دالة معينة بدقة.

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

إحدى الإجابات الممكنة نظام قدرات هرمي (capability system) – يقدم قدرات دقيقة مثل BlockingIO وNonBlockingIO وأخرى أوسع مثل IO. وعندئذ يمكن لنظام الأنواع أن يرشدنا إلى معالجة كل حالة بشكل صحيح، بما يغطي أنماط فشلها وخصائصها وقت التشغيل.

خلاصة

إليك بعض ما تعلمناه في الطريق:

  • الفرق بين الخيوط الحاملة والخيوط الافتراضية، وحقيقة أن Loom يشغّل خيوطاً افتراضية كثيرة على مجمّع صغير من الخيوط الحاملة.
  • جزء من Loom هو تحديث عمليات الحجب لتصبح واعية بالخيوط الافتراضية.
  • نُقلت بنى التزامن مثل الأقفال وsemaphores، وكذلك الشبكات المعتمدة على sockets، لتعمل بصورة صحيحة مع الخيوط الافتراضية.
  • لكن هذا لا ينطبق على كل واجهة حاجبة في JDK. وكلما حُجب خيط حامل، فنحن أمام تثبيت خيوط (thread pinning).
  • يحدث تثبيت الخيوط مع الكلمة المفتاحية synchronized، وكذلك أثناء الإدخال والإخراج للملفات، وعند استخدام datagram sockets، وعند تحويل أسماء النطاقات.
  • هناك طرق لتجنب تثبيت الخيوط: استبدال synchronized بأقفال، وبدء خيوط حاملة معوّضة. ويفعل JDK الأخيرة بنفسه (حتى الحد المضبوط) كلما استُدعيت عملية إدخال وإخراج تحجب الخيط الحامل.
  • بعض العمليات، مثل الإدخال والإخراج للملفات، حاجبة بطبيعتها على مستوى النواة، ولا يستطيع Loom جعلها غير حاجبة.
  • io_uring يحل المشكلة جزئياً فقط، لأنه يعتمد داخلياً على مجمّع خيوط لتشغيل العمليات الحاجبة (مثل الإدخال والإخراج للملفات).

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

قد تكون الإجابة ببساطة “هذا يعتمد”. فبعد مقياس معين تبدأ هذه التفاصيل في الأهمية. وعند المقاييس الأصغر قد لا تكون ذات صلة. تجريدات مثل Loom أو io_uring متسرِّبة وقد تضلل. ولعل بعض الإرشاد من نظام الأنواع يفيد. أو لعل هذه المعلومة يمكن إيصالها بطريقة مختلفة؟ وأخيراً، قد نرغب في وسيلة لإخبار بيئات تشغيلنا بأن تفشل عندما يتعذر تنفيذ عملية إدخال وإخراج بطريقة معينة.

يدفع Loom الـ JVM إلى الأمام كثيراً ويحقق أهداف أدائه مع تبسيط نموذج البرمجة؛ لكن لا يمكننا الاعتماد عليه اعتماداً أعمى للتخلص من كل مصدر لحجب خيوط النواة في تطبيقاتنا. بل قد يُدخل مشكلات أداء جديدة في تطبيقاتنا وهو يعالج مشكلات أخرى.

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