كيف تعمل Tasks والتوازي بما يتجاوز async/await؟

Question

Accepted Answer

بما يتجاوز `async`/`await` للعمليات الإدخالية/الإخراجية، توفر .NET مكتبة **Task Parallel Library (TPL)** لـ **التوازي المرتبط بوحدة المعالجة المركزية** — تشغيل الحسابات عبر أنوية متعددة. التمييز الرئيسي: `async`/`await` مخصصة للتزامن المتزامن للعمليات الإدخالية/الإخراجية (الانتظار غير المحجوب)، بينما `Task.Run`، `Parallel`، و PLINQ مخصصة لتوازي العمل الذي يثقل على وحدة المعالجة المركزية.

## التمييز الحاسم: التزامن مقابل التوازي

```text
async/await → I/O-bound concurrency. Frees the thread during waits (DB, network).
              Does NOT add CPU parallelism.
Parallelism → CPU-bound work spread across MULTIPLE CORES (computation, processing).
              Use Task.Run, Parallel.For/ForEach, PLINQ.
```

## Task.Run — نقل عمل وحدة المعالجة المركزية إلى خيط خلفي

```csharp
// run a CPU-intensive computation on a thread pool thread (don't block the caller)
int result = await Task.Run(() => ExpensiveComputation());

// run multiple in parallel and combine
var tasks = items.Select(item => Task.Run(() => Process(item)));
var results = await Task.WhenAll(tasks);   // wait for all
```

`Task.Run` يجدول العمل على خيط من مجموعة الخيوط — استخدمه لتوازي الحسابات المرتبطة بوحدة المعالجة المركزية (ليس للعمليات الإدخالية/الإخراجية، حيث يوفر async/await بالفعل الكفاية دون خيوط إضافية).

## Parallel و PLINQ — توازي البيانات

```csharp
// Parallel.For/ForEach — process a collection across cores
Parallel.ForEach(items, item => Process(item));   // automatically uses multiple cores
Parallel.For(0, 1000, i => Compute(i));

// PLINQ — parallel LINQ
var results = data.AsParallel().Where(x => IsValid(x)).Select(Transform).ToList();
```

`Parallel.For`/`ForEach` و **PLINQ** (`.AsParallel()`) توزع العمل تلقائياً على الأنوية — رائعة للمعالجة الثقيلة على وحدة المعالجة المركزية للعناصر المستقلة. (يستحق الأمر فقط للعمل الذي يثقل فعلاً على وحدة المعالجة المركزية وذو حجم كبير — هناك نفقات عامة.)

## سلامة الخيط (الجزء الصعب)

```csharp
// parallel code accessing SHARED state needs synchronization or thread-safe types
lock (_lock) { _counter++; }                          // lock for mutual exclusion
Interlocked.Increment(ref _counter);                   // lock-free atomic
var dict = new ConcurrentDictionary<string, int>();    // thread-safe collection
```

## لماذا يهم

فهم Tasks والتوازي بما يتجاوز async/await هو معرفة مهمة على مستوى الكبار لبناء تطبيقات C# عالية الأداء، و **التمييز الحاسم بين التزامن المتزامن للعمليات الإدخالية/الإخراجية والتوازي المرتبط بوحدة المعالجة المركزية** هو الفكرة الرئيسية — نقطة التباس شائعة. `async`/`await` تتعامل مع التزامن المتزامن المرتبط بالعمليات الإدخالية/الإخراجية (تحرير الخيوط أثناء الانتظار) لكنها لا تضيف توازياً على وحدة المعالجة المركزية، بينما العمل المرتبط بوحدة المعالجة المركزية (الحسابات، معالجة البيانات) يستفيد من التوازي الفعلي عبر الأنوية عبر **`Task.Run`** (نقل عمل وحدة المعالجة المركزية إلى خيوط مجموعة الخيوط)، **`Parallel.For`/`ForEach`**، و **PLINQ** (`.AsParallel()`).

معرفة الأداة التي تناسب — async/await للعمليات الإدخالية/الإخراجية، وأدوات التوازي من TPL للعمل المرتبط بوحدة المعالجة المركزية — ضرورية لتحسين الأداء الفعال، لأن استخدام الأداة الخاطئة (على سبيل المثال توقع أن تسرع async الحسابات، أو إنشاء خيوط للعمليات الإدخالية/الإخراجية التي تتعامل معها async بكفاءة) غير فعال.

من المهم بنفس القدر فهم **سلامة الخيط**: الكود المتوازي الذي يصل إلى حالة مشتركة يحتاج إلى المزامنة (`lock`، `Interlocked` للعمليات الذرية، أو المجموعات الآمنة للخيوط مثل `ConcurrentDictionary`) لتجنب حالات التسابق — مشكلة صحة حرجة في الكود المتوازي.

فهم التمييز بين العمليات الإدخالية/الإخراجية ووحدة المعالجة المركزية، وأدوات التوازي (Task.Run, Parallel, PLINQ)، ومتطلبات سلامة الخيط قيم لكتابة كود C# متزامن ومتوازي صحيح وعالي الأداء.

نظراً لأن التطبيقات الحديثة غالباً ما تحتاج إلى التزامن المتزامن للعمليات الإدخالية/الإخراجية والتوازي المرتبط بوحدة المعالجة المركزية معاً، ونظراً لأن اختيار النهج الصحيح والتعامل الصحيح مع سلامة الخيط هو ما يجعل الكود المتوازي فعالاً وصحيحاً، فهذه معرفة مهمة وذات صلة متكررة على مستوى الكبار لتطوير C# حساس للأداء.