تسلط بر همزمانی: ساخت یک ترای (Trie) امن برای نخ‌ها (Thread-Safe) در جاوا اسکریپت برای اپلیکیشن‌های جهانی

در دنیای متصل امروز، اپلیکیشن‌ها نه تنها به سرعت، بلکه به پاسخگویی و توانایی مدیریت عملیات‌های عظیم و همزمان نیاز دارند. جاوا اسکریپت، که به طور سنتی به خاطر ماهیت تک‌نخی (single-threaded) خود در مرورگر شناخته می‌شود، به طور قابل توجهی تکامل یافته و ابزارهای قدرتمندی برای مقابله با موازی‌سازی واقعی ارائه می‌دهد. یکی از ساختارهای داده رایج که اغلب با چالش‌های همزمانی مواجه می‌شود، به ویژه هنگام کار با مجموعه‌داده‌های بزرگ و پویا در یک زمینه چندنخی، ترای (Trie) است که به آن درخت پیشوندی (Prefix Tree) نیز گفته می‌شود.

تصور کنید در حال ساخت یک سرویس تکمیل خودکار جهانی، یک فرهنگ لغت آنی، یا یک جدول مسیریابی IP پویا هستید که در آن میلیون‌ها کاربر یا دستگاه به طور مداوم در حال پرس‌وجو و به‌روزرسانی داده‌ها هستند. یک ترای استاندارد، با وجود کارایی فوق‌العاده برای جستجوهای مبتنی بر پیشوند، در یک محیط همزمان به سرعت به یک گلوگاه تبدیل می‌شود و در برابر شرایط رقابتی (race conditions) و خرابی داده آسیب‌پذیر است. این راهنمای جامع به چگونگی ساخت یک ترای همزمان جاوا اسکریپت می‌پردازد و آن را با استفاده هوشمندانه از SharedArrayBuffer و Atomics به صورت امن برای نخ‌ها (Thread-Safe) درمی‌آورد تا راه‌حل‌های قوی و مقیاس‌پذیر برای مخاطبان جهانی فراهم کند.

درک ترای‌ها: بنیان داده‌های مبتنی بر پیشوند

قبل از اینکه به پیچیدگی‌های همزمانی بپردازیم، بیایید درک دقیقی از اینکه ترای چیست و چرا اینقدر ارزشمند است، به دست آوریم.

ترای چیست؟

ترای، که از کلمه 'retrieval' (بازیابی) گرفته شده و «تری» یا «ترای» تلفظ می‌شود، یک ساختار داده درختی مرتب است که برای ذخیره یک مجموعه پویا یا آرایه انجمنی که کلیدهای آن معمولاً رشته هستند، استفاده می‌شود. برخلاف یک درخت جستجوی دودویی، که در آن گره‌ها کلید واقعی را ذخیره می‌کنند، گره‌های یک ترای بخش‌هایی از کلیدها را ذخیره می‌کنند و موقعیت یک گره در درخت، کلید مرتبط با آن را تعریف می‌کند.

• گره‌ها و یال‌ها: هر گره معمولاً یک کاراکتر را نشان می‌دهد و مسیر از ریشه تا یک گره خاص، یک پیشوند را تشکیل می‌دهد.
• فرزندان: هر گره ارجاعاتی به فرزندان خود دارد، معمولاً در یک آرایه یا نقشه، که در آن اندیس/کلید با کاراکتر بعدی در یک دنباله مطابقت دارد.
• پرچم پایانی: گره‌ها همچنین می‌توانند یک پرچم 'terminal' یا 'isWord' داشته باشند تا نشان دهند مسیری که به آن گره ختم می‌شود، یک کلمه کامل را نشان می‌دهد.

این ساختار امکان عملیات بسیار کارآمد مبتنی بر پیشوند را فراهم می‌کند و آن را برای موارد استفاده خاص، برتر از جداول هش یا درختان جستجوی دودویی می‌سازد.

موارد استفاده رایج برای ترای‌ها

کارایی ترای‌ها در مدیریت داده‌های رشته‌ای، آن‌ها را در اپلیکیشن‌های مختلفی ضروری می‌سازد:

• تکمیل خودکار و پیشنهادات تایپ (Type-ahead): شاید مشهورترین کاربرد آن باشد. به موتورهای جستجو مانند گوگل، ویرایشگرهای کد (IDE) یا اپلیکیشن‌های پیام‌رسان فکر کنید که هنگام تایپ، پیشنهاداتی ارائه می‌دهند. یک ترای می‌تواند به سرعت تمام کلماتی را که با یک پیشوند مشخص شروع می‌شوند، پیدا کند.
  • مثال جهانی: ارائه پیشنهادات تکمیل خودکار آنی و محلی‌شده در ده‌ها زبان برای یک پلتفرم تجارت الکترونیک بین‌المللی.
• بررسی‌کننده‌های املا (Spell Checkers): با ذخیره یک فرهنگ لغت از کلمات با املای صحیح، یک ترای می‌تواند به طور کارآمد بررسی کند که آیا یک کلمه وجود دارد یا جایگزین‌هایی بر اساس پیشوندها پیشنهاد دهد.
  • مثال جهانی: اطمینان از املای صحیح برای ورودی‌های زبانی متنوع در یک ابزار تولید محتوای جهانی.
• جداول مسیریابی IP: ترای‌ها برای تطبیق طولانی‌ترین پیشوند (longest-prefix matching) عالی هستند، که در مسیریابی شبکه برای تعیین مشخص‌ترین مسیر برای یک آدرس IP امری بنیادی است.
  • مثال جهانی: بهینه‌سازی مسیریابی بسته‌های داده در شبکه‌های وسیع بین‌المللی.
• جستجوی فرهنگ لغت: جستجوی سریع کلمات و تعاریف آن‌ها.
  • مثال جهانی: ساخت یک فرهنگ لغت چندزبانه که از جستجوهای سریع در میان صدها هزار کلمه پشتیبانی می‌کند.
• بیوانفورماتیک: برای تطبیق الگو در توالی‌های DNA و RNA، جایی که رشته‌های طولانی رایج هستند، استفاده می‌شود.
  • مثال جهانی: تحلیل داده‌های ژنومی که توسط موسسات تحقیقاتی در سراسر جهان ارائه شده است.

چالش همزمانی در جاوا اسکریپت

شهرت جاوا اسکریپت به تک‌نخی بودن، عمدتاً برای محیط اجرای اصلی آن، به ویژه در مرورگرهای وب، صادق است. با این حال، جاوا اسکریپت مدرن مکانیزم‌های قدرتمندی برای دستیابی به موازی‌سازی فراهم می‌کند و با آن، چالش‌های کلاسیک برنامه‌نویسی همزمان را معرفی می‌کند.

ماهیت تک‌نخی جاوا اسکریپت (و محدودیت‌های آن)

موتور جاوا اسکریپت روی نخ اصلی (main thread) وظایف را به صورت متوالی از طریق یک حلقه رویداد (event loop) پردازش می‌کند. این مدل بسیاری از جنبه‌های توسعه وب را ساده می‌کند و از مشکلات رایج همزمانی مانند بن‌بست (deadlocks) جلوگیری می‌کند. با این حال، برای کارهای محاسباتی سنگین، می‌تواند منجر به عدم پاسخگویی رابط کاربری (UI) و تجربه کاربری ضعیف شود.

ظهور Web Workers: همزمانی واقعی در مرورگر

Web Workers راهی برای اجرای اسکریپت‌ها در نخ‌های پس‌زمینه، جدا از نخ اجرای اصلی یک صفحه وب، فراهم می‌کنند. این بدان معناست که وظایف طولانی‌مدت و وابسته به CPU می‌توانند به پس‌زمینه منتقل شوند و رابط کاربری را پاسخگو نگه دارند. داده‌ها معمولاً بین نخ اصلی و ورکرها، یا بین خود ورکرها، با استفاده از مدل ارسال پیام (postMessage()) به اشتراک گذاشته می‌شوند.

• ارسال پیام (Message Passing): داده‌ها هنگام ارسال بین نخ‌ها به صورت 'structured cloned' (کپی) می‌شوند. برای پیام‌های کوچک، این روش کارآمد است. با این حال، برای ساختارهای داده بزرگ مانند یک ترای که ممکن است میلیون‌ها گره داشته باشد، کپی کردن مکرر کل ساختار بسیار پرهزینه می‌شود و مزایای همزمانی را از بین می‌برد.
  • در نظر بگیرید: اگر یک ترای داده‌های فرهنگ لغت یک زبان اصلی را در خود نگه دارد، کپی کردن آن برای هر تعامل با ورکر ناکارآمد است.

مشکل: وضعیت اشتراکی قابل تغییر و شرایط رقابتی

هنگامی که چندین نخ (Web Workers) نیاز به دسترسی و تغییر یک ساختار داده یکسان دارند، و آن ساختار داده قابل تغییر (mutable) است، شرایط رقابتی به یک نگرانی جدی تبدیل می‌شود. یک ترای، به طبیعت خود، قابل تغییر است: کلمات درج، جستجو و گاهی حذف می‌شوند. بدون همگام‌سازی مناسب، عملیات همزمان می‌تواند منجر به موارد زیر شود:

• خرابی داده: دو ورکر که به طور همزمان سعی در درج یک گره جدید برای یک کاراکتر یکسان دارند، ممکن است تغییرات یکدیگر را بازنویسی کنند و منجر به یک ترای ناقص یا نادرست شوند.
• خواندن‌های ناسازگار: یک ورکر ممکن است یک ترای نیمه‌به‌روز شده را بخواند که منجر به نتایج جستجوی نادرست می‌شود.
• به‌روزرسانی‌های از دست رفته: تغییرات یک ورکر ممکن است به طور کامل از بین برود اگر ورکر دیگری بدون در نظر گرفتن تغییر اولی، آن را بازنویسی کند.

به همین دلیل است که یک ترای استاندارد مبتنی بر شیء در جاوا اسکریپت، با وجود عملکرد در یک زمینه تک‌نخی، مطلقاً برای اشتراک‌گذاری و تغییر مستقیم بین Web Workers مناسب نیست. راه‌حل در مدیریت صریح حافظه و عملیات اتمیک نهفته است.

دستیابی به امنیت نخ‌ها: ابزارهای اولیه همزمانی در جاوا اسکریپت

برای غلبه بر محدودیت‌های ارسال پیام و فراهم کردن یک وضعیت اشتراکی واقعاً امن برای نخ‌ها، جاوا اسکریپت ابزارهای اولیه قدرتمند سطح پایینی را معرفی کرد: SharedArrayBuffer و Atomics.

معرفی SharedArrayBuffer

SharedArrayBuffer یک بافر داده باینری خام با طول ثابت است، شبیه به ArrayBuffer، اما با یک تفاوت حیاتی: محتویات آن می‌تواند بین چندین Web Worker به اشتراک گذاشته شود. به جای کپی کردن داده‌ها، ورکرها می‌توانند مستقیماً به همان حافظه زیربنایی دسترسی داشته باشند و آن را تغییر دهند. این کار سربار انتقال داده برای ساختارهای داده بزرگ و پیچیده را از بین می‌برد.

• حافظه اشتراکی: یک SharedArrayBuffer یک ناحیه واقعی از حافظه است که تمام Web Workerهای مشخص شده می‌توانند از آن بخوانند و در آن بنویسند.
• بدون شبیه‌سازی (Cloning): وقتی یک SharedArrayBuffer را به یک Web Worker ارسال می‌کنید، یک ارجاع به همان فضای حافظه منتقل می‌شود، نه یک کپی.
• ملاحظات امنیتی: به دلیل حملات بالقوه به سبک Spectre، SharedArrayBuffer نیازمندی‌های امنیتی خاصی دارد. برای مرورگرهای وب، این معمولاً شامل تنظیم هدرهای HTTP Cross-Origin-Opener-Policy (COOP) و Cross-Origin-Embedder-Policy (COEP) به same-origin یا credentialless است. این یک نکته حیاتی برای استقرار جهانی است، زیرا پیکربندی‌های سرور باید به‌روز شوند. محیط‌های Node.js (با استفاده از worker_threads) این محدودیت‌های خاص مرورگر را ندارند.

با این حال، یک SharedArrayBuffer به تنهایی مشکل شرایط رقابتی را حل نمی‌کند. این ابزار حافظه اشتراکی را فراهم می‌کند، اما مکانیزم‌های همگام‌سازی را نه.

قدرت Atomics

Atomics یک شیء سراسری است که عملیات اتمیک را برای حافظه اشتراکی فراهم می‌کند. 'اتمیک' به این معناست که تضمین می‌شود عملیات به طور کامل و بدون وقفه توسط هیچ نخ دیگری به پایان می‌رسد. این امر یکپارچگی داده را هنگام دسترسی چندین ورکر به مکان‌های حافظه یکسان در یک SharedArrayBuffer تضمین می‌کند.

متدهای کلیدی Atomics که برای ساخت یک ترای همزمان حیاتی هستند، عبارتند از:

• Atomics.load(typedArray, index): به صورت اتمیک یک مقدار را در یک اندیس مشخص در یک TypedArray که توسط SharedArrayBuffer پشتیبانی می‌شود، بارگذاری می‌کند.
  • کاربرد: برای خواندن خصوصیات گره (مانند اشاره‌گرهای فرزند، کدهای کاراکتر، پرچم‌های پایانی) بدون تداخل.
• Atomics.store(typedArray, index, value): به صورت اتمیک یک مقدار را در یک اندیس مشخص ذخیره می‌کند.
  • کاربرد: برای نوشتن خصوصیات جدید گره.
• Atomics.add(typedArray, index, value): به صورت اتمیک یک مقدار را به مقدار موجود در اندیس مشخص شده اضافه می‌کند و مقدار قدیمی را برمی‌گرداند. برای شمارنده‌ها (مثلاً افزایش شمارنده ارجاع یا اشاره‌گر 'آدرس حافظه در دسترس بعدی') مفید است.
• Atomics.compareExchange(typedArray, index, expectedValue, replacementValue): این مسلماً قدرتمندترین عملیات اتمیک برای ساختارهای داده همزمان است. این متد به صورت اتمیک بررسی می‌کند که آیا مقدار در index با expectedValue مطابقت دارد یا خیر. اگر مطابقت داشته باشد، مقدار را با replacementValue جایگزین می‌کند و مقدار قدیمی (که همان expectedValue بود) را برمی‌گرداند. اگر مطابقت نداشته باشد، تغییری رخ نمی‌دهد و مقدار واقعی در index را برمی‌گرداند.
  • کاربرد: پیاده‌سازی قفل‌ها (spinlocks یا mutexes)، همزمانی خوش‌بینانه، یا اطمینان از اینکه یک تغییر فقط در صورتی اتفاق می‌افتد که وضعیت همان چیزی باشد که انتظار می‌رفت. این برای ایجاد گره‌های جدید یا به‌روزرسانی امن اشاره‌گرها حیاتی است.
• Atomics.wait(typedArray, index, value, [timeout]) و Atomics.notify(typedArray, index, [count]): اینها برای الگوهای همگام‌سازی پیشرفته‌تر استفاده می‌شوند و به ورکرها اجازه می‌دهند تا برای یک شرط خاص مسدود شده و منتظر بمانند، سپس هنگامی که تغییر کرد مطلع شوند. برای الگوهای تولیدکننده-مصرف‌کننده یا مکانیزم‌های قفل‌گذاری پیچیده مفید است.

هم‌افزایی SharedArrayBuffer برای حافظه اشتراکی و Atomics برای همگام‌سازی، بنیان لازم را برای ساخت ساختارهای داده پیچیده و امن برای نخ‌ها مانند ترای همزمان ما در جاوا اسکریپت فراهم می‌کند.

طراحی یک ترای همزمان با SharedArrayBuffer و Atomics

ساخت یک ترای همزمان صرفاً به معنای ترجمه یک ترای شیءگرا به یک ساختار حافظه اشتراکی نیست. این کار نیازمند یک تغییر اساسی در نحوه نمایش گره‌ها و نحوه همگام‌سازی عملیات است.

ملاحظات معماری

نمایش ساختار ترای در یک SharedArrayBuffer

به جای اشیاء جاوا اسکریپت با ارجاعات مستقیم، گره‌های ترای ما باید به صورت بلوک‌های پیوسته حافظه در یک SharedArrayBuffer نمایش داده شوند. این به معنای:

• تخصیص حافظه خطی: ما معمولاً از یک SharedArrayBuffer واحد استفاده می‌کنیم و آن را به عنوان یک آرایه بزرگ از 'اسلات‌ها' یا 'صفحات' با اندازه ثابت مشاهده می‌کنیم، که در آن هر اسلات یک گره ترای را نشان می‌دهد.
• اشاره‌گرهای گره به عنوان اندیس: به جای ذخیره ارجاعات به اشیاء دیگر، اشاره‌گرهای فرزند، اندیس‌های عددی خواهند بود که به موقعیت شروع یک گره دیگر در همان SharedArrayBuffer اشاره می‌کنند.
• گره‌های با اندازه ثابت: برای ساده‌سازی مدیریت حافظه، هر گره ترای تعداد بایت‌های از پیش تعریف‌شده‌ای را اشغال خواهد کرد. این اندازه ثابت کاراکتر، اشاره‌گرهای فرزند و پرچم پایانی آن را در خود جای می‌دهد.

بیایید یک ساختار گره ساده‌شده را در SharedArrayBuffer در نظر بگیریم. هر گره می‌تواند آرایه‌ای از اعداد صحیح باشد (مثلاً نماهای Int32Array یا Uint32Array روی SharedArrayBuffer)، که در آن:

• اندیس ۰: `characterCode` (مثلاً مقدار ASCII/یونیکد کاراکتری که این گره نشان می‌دهد، یا ۰ برای ریشه).
• اندیس ۱: `isTerminal` (۰ برای false، ۱ برای true).
• اندیس ۲ تا N: `children[0...25]` (یا بیشتر برای مجموعه‌های کاراکتری گسترده‌تر)، که در آن هر مقدار یک اندیس به یک گره فرزند در SharedArrayBuffer است، یا ۰ اگر فرزندی برای آن کاراکتر وجود نداشته باشد.
• یک اشاره‌گر `nextFreeNodeIndex` در جایی از بافر (یا مدیریت شده به صورت خارجی) برای تخصیص گره‌های جدید.

مثال: اگر یک گره ۳۰ اسلات `Int32` را اشغال کند، و SharedArrayBuffer ما به عنوان یک `Int32Array` مشاهده شود، آنگاه گره در اندیس `i` از `i * 30` شروع می‌شود.

مدیریت بلوک‌های حافظه آزاد

هنگامی که گره‌های جدید درج می‌شوند، باید فضا تخصیص دهیم. یک رویکرد ساده، حفظ یک اشاره‌گر به اولین اسلات آزاد موجود در SharedArrayBuffer است. این اشاره‌گر خود باید به صورت اتمیک به‌روز شود.

پیاده‌سازی درج امن برای نخ‌ها (عملیات `insert`)

درج، پیچیده‌ترین عملیات است زیرا شامل تغییر ساختار ترای، ایجاد بالقوه گره‌های جدید و به‌روزرسانی اشاره‌گرها می‌شود. اینجاست که `Atomics.compareExchange()` برای تضمین سازگاری حیاتی می‌شود.

بیایید مراحل درج کلمه‌ای مانند "apple" را تشریح کنیم:

مراحل مفهومی برای درج امن برای نخ‌ها:

1. شروع از ریشه: پیمایش را از گره ریشه (در اندیس ۰) آغاز کنید. ریشه معمولاً خود یک کاراکتر را نشان نمی‌دهد.
2. پیمایش کاراکتر به کاراکتر: برای هر کاراکتر در کلمه (مثلاً 'a', 'p', 'p', 'l', 'e'):
   1. تعیین اندیس فرزند: اندیس مربوط به کاراکتر فعلی را در اشاره‌گرهای فرزند گره فعلی محاسبه کنید. (مثلاً `children[char.charCodeAt(0) - 'a'.charCodeAt(0)]`).
   2. بارگذاری اتمیک اشاره‌گر فرزند: از `Atomics.load(typedArray, current_node_child_pointer_index)` برای دریافت اندیس شروع گره فرزند بالقوه استفاده کنید.
   3. بررسی وجود فرزند:
      • اگر اشاره‌گر فرزند بارگذاری‌شده ۰ باشد (فرزندی وجود ندارد): اینجاست که باید یک گره جدید ایجاد کنیم.
        1. تخصیص اندیس گره جدید: به صورت اتمیک یک اندیس منحصر به فرد جدید برای گره جدید به دست آورید. این معمولاً شامل افزایش اتمیک یک شمارنده 'گره در دسترس بعدی' است (مثلاً `newNodeIndex = Atomics.add(typedArray, NEXT_FREE_NODE_INDEX_OFFSET, NODE_SIZE)`). مقدار بازگشتی، مقدار *قدیمی* قبل از افزایش است که آدرس شروع گره جدید ماست.
        2. مقداردهی اولیه گره جدید: کد کاراکتر و `isTerminal = 0` را با استفاده از `Atomics.store()` در ناحیه حافظه گره تازه تخصیص‌یافته بنویسید.
        3. تلاش برای پیوند دادن گره جدید: این مرحله حیاتی برای امنیت نخ‌هاست. از `Atomics.compareExchange(typedArray, current_node_child_pointer_index, 0, newNodeIndex)` استفاده کنید.
           • اگر `compareExchange` مقدار ۰ را برگرداند (به این معنی که اشاره‌گر فرزند هنگام تلاش ما برای پیوند دادن آن واقعاً ۰ بود)، پس گره جدید ما با موفقیت پیوند داده شده است. به گره جدید به عنوان `current_node` بروید.
           • اگر `compareExchange` یک مقدار غیر صفر را برگرداند (به این معنی که ورکر دیگری در این فاصله با موفقیت یک گره برای این کاراکتر پیوند داده است)، پس ما با یک برخورد مواجه شده‌ایم. ما گره تازه ایجاد شده خود را *دور می‌اندازیم* (یا اگر یک استخر را مدیریت می‌کنیم، آن را به یک لیست آزاد برمی‌گردانیم) و به جای آن از اندیس بازگشتی توسط `compareExchange` به عنوان `current_node` خود استفاده می‌کنیم. ما عملاً مسابقه را 'می‌بازیم' و از گره ایجاد شده توسط برنده استفاده می‌کنیم.
      • اگر اشاره‌گر فرزند بارگذاری‌شده غیر صفر باشد (فرزند از قبل وجود دارد): به سادگی `current_node` را به اندیس فرزند بارگذاری‌شده تنظیم کرده و به کاراکتر بعدی ادامه دهید.
3. علامت‌گذاری به عنوان پایانی: پس از پردازش تمام کاراکترها، پرچم `isTerminal` گره نهایی را با استفاده از `Atomics.store()` به صورت اتمیک به ۱ تنظیم کنید.

این استراتژی قفل‌گذاری خوش‌بینانه با `Atomics.compareExchange()` حیاتی است. به جای استفاده از mutexهای صریح (که `Atomics.wait`/`notify` می‌توانند به ساخت آن کمک کنند)، این رویکرد سعی می‌کند تغییری ایجاد کند و تنها در صورت شناسایی تداخل، آن را بازگردانده یا تطبیق می‌دهد، که آن را برای بسیاری از سناریوهای همزمان کارآمد می‌سازد.

شبه‌کد نمایشی (ساده‌شده) برای درج:

const NODE_SIZE = 30; // مثال: ۲ برای متادیتا + ۲۸ برای فرزندان
const CHARACTER_CODE_OFFSET = 0;
const IS_TERMINAL_OFFSET = 1;
const CHILDREN_OFFSET = 2;
const NEXT_FREE_NODE_INDEX_OFFSET = 0; // در ابتدای بافر ذخیره می‌شود

// با فرض اینکه 'sharedBuffer' یک نمای Int32Array روی SharedArrayBuffer است
function insertWord(word, sharedBuffer) {
    let currentNodeIndex = NODE_SIZE; // گره ریشه بعد از اشاره‌گر فضای خالی شروع می‌شود

    for (let i = 0; i < word.length; i++) {
        const charCode = word.charCodeAt(i);
        const childIndexInNode = charCode - 'a'.charCodeAt(0) + CHILDREN_OFFSET;
        const childPointerOffset = currentNodeIndex + childIndexInNode;

        let nextNodeIndex = Atomics.load(sharedBuffer, childPointerOffset);

        if (nextNodeIndex === 0) {
            // فرزندی وجود ندارد، تلاش برای ایجاد یکی
            const allocatedNodeIndex = Atomics.add(sharedBuffer, NEXT_FREE_NODE_INDEX_OFFSET, NODE_SIZE);

            // مقداردهی اولیه گره جدید
            Atomics.store(sharedBuffer, allocatedNodeIndex + CHARACTER_CODE_OFFSET, charCode);
            Atomics.store(sharedBuffer, allocatedNodeIndex + IS_TERMINAL_OFFSET, 0);
            // تمام اشاره‌گرهای فرزند به طور پیش‌فرض ۰ هستند
            for (let k = 0; k < NODE_SIZE - CHILDREN_OFFSET; k++) {
                Atomics.store(sharedBuffer, allocatedNodeIndex + CHILDREN_OFFSET + k, 0);
            }

            // تلاش برای پیوند دادن گره جدید به صورت اتمیک
            const actualOldValue = Atomics.compareExchange(sharedBuffer, childPointerOffset, 0, allocatedNodeIndex);

            if (actualOldValue === 0) {
                // گره ما با موفقیت پیوند داده شد، ادامه می‌دهیم
                nextNodeIndex = allocatedNodeIndex;
            } else {
                // ورکر دیگری یک گره را پیوند داد؛ از گره آن استفاده می‌کنیم. گره تخصیص‌داده‌شده ما اکنون بلااستفاده است.
                // در یک سیستم واقعی، شما در اینجا یک لیست آزاد را به طور قوی‌تری مدیریت می‌کنید.
                // برای سادگی، ما فقط از گره برنده استفاده می‌کنیم.
                nextNodeIndex = actualOldValue;
            }
        }
        currentNodeIndex = nextNodeIndex;
    }
    // گره نهایی را به عنوان پایانی علامت‌گذاری کن
    Atomics.store(sharedBuffer, currentNodeIndex + IS_TERMINAL_OFFSET, 1);
}

پیاده‌سازی جستجوی امن برای نخ‌ها (عملیات `search` و `startsWith`)

عملیات خواندن مانند جستجوی یک کلمه یا یافتن تمام کلمات با یک پیشوند مشخص، عموماً ساده‌تر هستند، زیرا شامل تغییر ساختار نمی‌شوند. با این حال، آنها هنوز باید از بارگذاری‌های اتمیک استفاده کنند تا اطمینان حاصل شود که مقادیر سازگار و به‌روزی را می‌خوانند و از خواندن‌های جزئی ناشی از نوشتن‌های همزمان جلوگیری می‌کنند.

مراحل مفهومی برای جستجوی امن برای نخ‌ها:

1. شروع از ریشه: از گره ریشه شروع کنید.
2. پیمایش کاراکتر به کاراکتر: برای هر کاراکتر در پیشوند جستجو:
   1. تعیین اندیس فرزند: آفست اشاره‌گر فرزند را برای کاراکتر محاسبه کنید.
   2. بارگذاری اتمیک اشاره‌گر فرزند: از `Atomics.load(typedArray, current_node_child_pointer_index)` استفاده کنید.
   3. بررسی وجود فرزند: اگر اشاره‌گر بارگذاری‌شده ۰ باشد، کلمه/پیشوند وجود ندارد. خارج شوید.
   4. حرکت به فرزند: اگر وجود دارد، `current_node` را به اندیس فرزند بارگذاری‌شده به‌روز کنید و ادامه دهید.
3. بررسی نهایی (برای `search`): پس از پیمایش کل کلمه، پرچم `isTerminal` گره نهایی را به صورت اتمیک بارگذاری کنید. اگر ۱ باشد، کلمه وجود دارد؛ در غیر این صورت، فقط یک پیشوند است.
4. برای `startsWith`: گره نهایی که به آن رسیده‌ایم، انتهای پیشوند را نشان می‌دهد. از این گره، یک جستجوی اول عمق (DFS) یا جستجوی اول سطح (BFS) می‌تواند (با استفاده از بارگذاری‌های اتمیک) برای یافتن تمام گره‌های پایانی در زیردرخت آن آغاز شود.

عملیات خواندن تا زمانی که به حافظه زیربنایی به صورت اتمیک دسترسی پیدا شود، ذاتاً امن هستند. منطق `compareExchange` در حین نوشتن تضمین می‌کند که هیچ اشاره‌گر نامعتبری هرگز ایجاد نمی‌شود و هر رقابتی در حین نوشتن به یک وضعیت سازگار (هرچند با تأخیر اندک برای یک ورکر) منجر می‌شود.

شبه‌کد نمایشی (ساده‌شده) برای جستجو:

function searchWord(word, sharedBuffer) {
    let currentNodeIndex = NODE_SIZE;

    for (let i = 0; i < word.length; i++) {
        const charCode = word.charCodeAt(i);
        const childIndexInNode = charCode - 'a'.charCodeAt(0) + CHILDREN_OFFSET;
        const childPointerOffset = currentNodeIndex + childIndexInNode;

        const nextNodeIndex = Atomics.load(sharedBuffer, childPointerOffset);

        if (nextNodeIndex === 0) {
            return false; // مسیر کاراکتر وجود ندارد
        }
        currentNodeIndex = nextNodeIndex;
    }
    // بررسی کن که آیا گره نهایی یک کلمه پایانی است
    return Atomics.load(sharedBuffer, currentNodeIndex + IS_TERMINAL_OFFSET) === 1;
}

پیاده‌سازی حذف امن برای نخ‌ها (پیشرفته)

حذف در یک محیط حافظه اشتراکی همزمان به طور قابل توجهی چالش‌برانگیزتر است. حذف ساده‌لوحانه می‌تواند منجر به موارد زیر شود:

• اشاره‌گرهای سرگردان (Dangling Pointers): اگر یک ورکر یک گره را حذف کند در حالی که ورکر دیگری در حال پیمایش به سمت آن است، ورکر در حال پیمایش ممکن است یک اشاره‌گر نامعتبر را دنبال کند.
• وضعیت ناسازگار: حذف‌های جزئی می‌توانند ترای را در یک وضعیت غیرقابل استفاده قرار دهند.
• تکه‌تکه شدن حافظه (Memory Fragmentation): بازپس‌گیری حافظه حذف شده به صورت امن و کارآمد پیچیده است.

استراتژی‌های رایج برای مدیریت ایمن حذف عبارتند از:

• حذف منطقی (علامت‌گذاری): به جای حذف فیزیکی گره‌ها، یک پرچم `isDeleted` می‌تواند به صورت اتمیک تنظیم شود. این کار همزمانی را ساده می‌کند اما حافظه بیشتری مصرف می‌کند.
• شمارش ارجاع / جمع‌آوری زباله (Garbage Collection): هر گره می‌تواند یک شمارنده ارجاع اتمیک داشته باشد. هنگامی که شمارنده ارجاع یک گره به صفر می‌رسد، واقعاً واجد شرایط حذف است و حافظه آن می‌تواند بازپس گرفته شود (مثلاً به یک لیست آزاد اضافه شود). این نیز نیازمند به‌روزرسانی‌های اتمیک برای شمارنده‌های ارجاع است.
• Read-Copy-Update (RCU): برای سناریوهایی با خواندن بسیار بالا و نوشتن کم، نویسندگان می‌توانند نسخه جدیدی از بخش اصلاح‌شده ترای ایجاد کنند و پس از اتمام، به صورت اتمیک یک اشاره‌گر را به نسخه جدید تعویض کنند. خواندن‌ها بر روی نسخه قدیمی ادامه می‌یابند تا زمانی که تعویض کامل شود. پیاده‌سازی این روش برای یک ساختار داده دانه‌ای مانند ترای پیچیده است اما تضمین‌های سازگاری قوی ارائه می‌دهد.

برای بسیاری از کاربردهای عملی، به ویژه آنهایی که به توان عملیاتی بالا نیاز دارند، یک رویکرد رایج این است که ترای‌ها را فقط-الحاقی (append-only) کرده یا از حذف منطقی استفاده کنند و بازپس‌گیری پیچیده حافظه را به زمان‌های کم‌اهمیت‌تر موکول کرده یا آن را به صورت خارجی مدیریت کنند. پیاده‌سازی حذف فیزیکی واقعی، کارآمد و اتمیک یک مسئله در سطح تحقیقاتی در ساختارهای داده همزمان است.

ملاحظات عملی و کارایی

ساخت یک ترای همزمان فقط به درستی آن مربوط نمی‌شود؛ بلکه به کارایی عملی و قابلیت نگهداری نیز بستگی دارد.

مدیریت حافظه و سربار

• مقداردهی اولیه `SharedArrayBuffer`: بافر باید از قبل به اندازه کافی تخصیص داده شود. تخمین حداکثر تعداد گره‌ها و اندازه ثابت آنها حیاتی است. تغییر اندازه پویا یک `SharedArrayBuffer` ساده نیست و اغلب شامل ایجاد یک بافر جدید و بزرگتر و کپی کردن محتویات است که هدف از حافظه اشتراکی برای عملیات مداوم را نقض می‌کند.
• کارایی فضا: گره‌های با اندازه ثابت، با وجود ساده‌سازی تخصیص حافظه و محاسبات اشاره‌گر، اگر بسیاری از گره‌ها مجموعه‌های فرزند پراکنده داشته باشند، می‌توانند از نظر حافظه کمتر کارآمد باشند. این یک مصالحه برای مدیریت ساده‌تر همزمان است.
• جمع‌آوری زباله دستی: هیچ جمع‌آوری زباله خودکاری در یک `SharedArrayBuffer` وجود ندارد. حافظه گره‌های حذف شده باید به صراحت مدیریت شود، اغلب از طریق یک لیست آزاد، تا از نشت حافظه و تکه‌تکه شدن آن جلوگیری شود. این کار پیچیدگی قابل توجهی را اضافه می‌کند.

محک‌زنی کارایی

چه زمانی باید یک ترای همزمان را انتخاب کنید؟ این یک راه‌حل جادویی برای همه شرایط نیست.

• تک‌نخی در مقابل چندنخی: برای مجموعه‌داده‌های کوچک یا همزمانی کم، یک ترای استاندارد مبتنی بر شیء روی نخ اصلی ممکن است به دلیل سربار راه‌اندازی ارتباط Web Worker و عملیات اتمیک، همچنان سریع‌تر باشد.
• عملیات نوشتن/خواندن همزمان بالا: ترای همزمان زمانی می‌درخشد که شما یک مجموعه‌داده بزرگ، حجم بالایی از عملیات نوشتن همزمان (درج، حذف) و بسیاری از عملیات خواندن همزمان (جستجو، جستجوی پیشوند) داشته باشید. این کار محاسبات سنگین را از نخ اصلی خارج می‌کند.
• سربار `Atomics`: عملیات اتمیک، با وجود ضروری بودن برای صحت، به طور کلی کندتر از دسترسی‌های غیر اتمیک به حافظه هستند. مزایا از اجرای موازی روی چندین هسته ناشی می‌شود، نه از عملیات فردی سریع‌تر. محک‌زنی مورد استفاده خاص شما برای تعیین اینکه آیا افزایش سرعت موازی‌سازی بر سربار اتمیک غلبه می‌کند یا خیر، حیاتی است.

مدیریت خطا و استحکام

اشکال‌زدایی برنامه‌های همزمان به طور بدنامی دشوار است. شرایط رقابتی می‌توانند گریزان و غیر قطعی باشند. آزمایش جامع، از جمله تست‌های استرس با بسیاری از ورکر‌های همزمان، ضروری است.

• تلاش مجدد: شکست عملیاتی مانند `compareExchange` به این معنی است که ورکر دیگری زودتر به آنجا رسیده است. منطق شما باید برای تلاش مجدد یا تطبیق آماده باشد، همانطور که در شبه‌کد درج نشان داده شد.
• زمان‌بندی (Timeouts): در همگام‌سازی‌های پیچیده‌تر، `Atomics.wait` می‌تواند یک زمان‌بندی داشته باشد تا از بن‌بست جلوگیری کند اگر یک `notify` هرگز نرسد.

پشتیبانی مرورگر و محیط

• Web Workers: به طور گسترده در مرورگرهای مدرن و Node.js (`worker_threads`) پشتیبانی می‌شود.
• `SharedArrayBuffer` و `Atomics`: در تمام مرورگرهای اصلی مدرن و Node.js پشتیبانی می‌شود. با این حال، همانطور که ذکر شد، محیط‌های مرورگر به دلیل نگرانی‌های امنیتی، برای فعال کردن `SharedArrayBuffer` به هدرهای HTTP خاص (COOP/COEP) نیاز دارند. این یک جزئیات استقرار حیاتی برای اپلیکیشن‌های وبی است که به دنبال دسترسی جهانی هستند.
  • تأثیر جهانی: اطمینان حاصل کنید که زیرساخت سرور شما در سراسر جهان برای ارسال صحیح این هدرها پیکربندی شده است.

موارد استفاده و تأثیر جهانی

توانایی ساخت ساختارهای داده امن برای نخ‌ها و همزمان در جاوا اسکریپت، دنیایی از امکانات را باز می‌کند، به ویژه برای اپلیکیشن‌هایی که به کاربران جهانی خدمات می‌دهند یا مقادیر عظیمی از داده‌های توزیع‌شده را پردازش می‌کنند.

• پلتفرم‌های جستجو و تکمیل خودکار جهانی: یک موتور جستجوی بین‌المللی یا یک پلتفرم تجارت الکترونیک را تصور کنید که نیاز به ارائه پیشنهادات تکمیل خودکار فوق‌سریع و آنی برای نام محصولات، مکان‌ها و پرس‌وجوهای کاربران در زبان‌ها و مجموعه‌های کاراکتری متنوع دارد. یک ترای همزمان در Web Workers می‌تواند حجم عظیم پرس‌وجوهای همزمان و به‌روزرسانی‌های پویا (مانند محصولات جدید، جستجوهای پرطرفدار) را بدون ایجاد تأخیر در نخ اصلی UI مدیریت کند.
• پردازش آنی داده از منابع توزیع‌شده: برای اپلیکیشن‌های اینترنت اشیاء (IoT) که داده‌ها را از حسگرهای سراسر قاره‌های مختلف جمع‌آوری می‌کنند، یا سیستم‌های مالی که فیدهای داده بازار را از بورس‌های مختلف پردازش می‌کنند، یک ترای همزمان می‌تواند به طور کارآمد جریان‌های داده مبتنی بر رشته (مانند شناسه‌های دستگاه، نمادهای سهام) را در لحظه ایندکس و جستجو کند و به چندین خط لوله پردازش اجازه دهد تا به صورت موازی روی داده‌های مشترک کار کنند.
• ویرایش مشارکتی و IDEها: در ویرایشگرهای اسناد مشارکتی آنلاین یا IDEهای مبتنی بر ابر، یک ترای مشترک می‌تواند بررسی آنی سینتکس، تکمیل کد یا بررسی املا را قدرت بخشد، که با تغییرات چندین کاربر از مناطق زمانی مختلف، فوراً به‌روز می‌شود. ترای مشترک یک نمای سازگار را برای تمام جلسات ویرایش فعال فراهم می‌کند.
• بازی و شبیه‌سازی: برای بازی‌های چندنفره مبتنی بر مرورگر، یک ترای همزمان می‌تواند جستجوهای فرهنگ لغت درون بازی (برای بازی‌های کلمه‌ای)، ایندکس‌های نام بازیکنان، یا حتی داده‌های مسیریابی هوش مصنوعی را در یک وضعیت جهانی مشترک مدیریت کند و اطمینان حاصل کند که تمام نخ‌های بازی بر روی اطلاعات سازگار برای گیم‌پلی پاسخگو عمل می‌کنند.
• اپلیکیشن‌های شبکه با کارایی بالا: در حالی که اغلب توسط سخت‌افزارهای تخصصی یا زبان‌های سطح پایین‌تر مدیریت می‌شود، یک سرور مبتنی بر جاوا اسکریپت (Node.js) می‌تواند از یک ترای همزمان برای مدیریت کارآمد جداول مسیریابی پویا یا تجزیه پروتکل‌ها استفاده کند، به ویژه در محیط‌هایی که انعطاف‌پذیری و استقرار سریع در اولویت قرار دارند.

این مثال‌ها نشان می‌دهند که چگونه انتقال عملیات رشته‌ای محاسباتی سنگین به نخ‌های پس‌زمینه، ضمن حفظ یکپارچگی داده از طریق یک ترای همزمان، می‌تواند به طور چشمگیری پاسخگویی و مقیاس‌پذیری اپلیکیشن‌هایی را که با تقاضاهای جهانی روبرو هستند، بهبود بخشد.

آینده همزمانی در جاوا اسکریپت

چشم‌انداز همزمانی در جاوا اسکریپت به طور مداوم در حال تحول است:

• WebAssembly و حافظه اشتراکی: ماژول‌های WebAssembly نیز می‌توانند روی `SharedArrayBuffer`ها کار کنند و اغلب کنترل دقیق‌تر و عملکرد بالقوه بالاتری را برای وظایف وابسته به CPU فراهم می‌کنند، در حالی که هنوز قادر به تعامل با Web Workers جاوا اسکریپت هستند.
• پیشرفت‌های بیشتر در ابزارهای اولیه جاوا اسکریپت: استاندارد ECMAScript به کاوش و اصلاح ابزارهای اولیه همزمانی ادامه می‌دهد و به طور بالقوه انتزاعات سطح بالاتری را ارائه می‌دهد که الگوهای رایج همزمان را ساده می‌کند.
• کتابخانه‌ها و فریم‌ورک‌ها: با بالغ شدن این ابزارهای اولیه سطح پایین، می‌توان انتظار داشت که کتابخانه‌ها و فریم‌ورک‌هایی ظهور کنند که پیچیدگی‌های `SharedArrayBuffer` و `Atomics` را پنهان می‌کنند و ساخت ساختارهای داده همزمان را برای توسعه‌دهندگان بدون دانش عمیق از مدیریت حافظه آسان‌تر می‌سازند.

پذیرش این پیشرفت‌ها به توسعه‌دهندگان جاوا اسکریپت اجازه می‌دهد تا مرزهای ممکن را جابجا کنند و اپلیکیشن‌های وب با کارایی و پاسخگویی بالا بسازند که بتوانند در برابر تقاضاهای دنیای متصل جهانی مقاومت کنند.

نتیجه‌گیری

سفر از یک ترای پایه به یک ترای همزمان کاملاً امن برای نخ‌ها در جاوا اسکریپت، گواهی بر تکامل باورنکردنی این زبان و قدرتی است که اکنون به توسعه‌دهندگان ارائه می‌دهد. با بهره‌گیری از SharedArrayBuffer و Atomics، می‌توانیم از محدودیت‌های مدل تک‌نخی فراتر رفته و ساختارهای داده‌ای بسازیم که قادر به مدیریت عملیات پیچیده و همزمان با یکپارچگی و کارایی بالا باشند.

این رویکرد بدون چالش نیست – نیازمند توجه دقیق به چیدمان حافظه، توالی عملیات اتمیک و مدیریت خطای قوی است. با این حال، برای اپلیکیشن‌هایی که با مجموعه‌داده‌های رشته‌ای بزرگ و قابل تغییر سر و کار دارند و به پاسخگویی در مقیاس جهانی نیاز دارند، ترای همزمان یک راه‌حل قدرتمند ارائه می‌دهد. این ابزار به توسعه‌دهندگان قدرت می‌بخشد تا نسل بعدی اپلیکیشن‌های بسیار مقیاس‌پذیر، تعاملی و کارآمد را بسازند و اطمینان حاصل کنند که تجربیات کاربری، صرف نظر از پیچیدگی پردازش داده‌های زیربنایی، یکپارچه باقی می‌ماند. آینده همزمانی جاوا اسکریپت اینجاست و با ساختارهایی مانند ترای همزمان، هیجان‌انگیزتر و تواناتر از همیشه است.