Threading Library — اردو/دھاگہ

The اردو/دھاگہ library provides threads, thread/process pools, locks, and events for concurrent programming in Urdu.

اردو: اردو/دھاگہ لائبریری ہم وقت پروگرامنگ کے لیے دھاگے (threads)، دھاگہ/عمل تالاب (pools)، تالہ (lock)، اور واقعہ (event) فراہم کرتی ہے۔

Import:

درآمد { دھاگہ, دھاگہ_تالاب, عمل_تالاب, تالہ, واقعہ } سے "اردو/دھاگہ"

Backend: Python threading, concurrent.futures.

Note: Use دھاگہ_تالاب for I/O-bound tasks (network, files). Use عمل_تالاب for CPU-bound tasks to bypass the GIL.

اردو: I/O پابند کاموں (نیٹ ورک، فائلیں) کے لیے دھاگہ_تالاب استعمال کریں۔ CPU پابند کاموں کے لیے عمل_تالاب استعمال کریں۔

دھاگہ — Thread

اردو: دھاگہ (thread) ایک آزاد عمل (process) کی شاخ ہے جو بیک وقت چل سکتی ہے۔

Constructor

متغیر ت = نیا دھاگہ(فنکشن, پیرامیٹر1, پیرامیٹر2, نام="دھاگہ", جمعہ=جھوٹ)

Parameter	Type	Default	Description
`فنکشن`	function	required	The function to run in the thread
`پیرامیٹر...`	any	—	Arguments passed to the function
`نام`	string	auto	Human-readable thread name
`جمعہ`	bool	`جھوٹ`	Daemon thread — exits when main thread exits

Instance methods — نمونے کے طریقے

Method	Returns	Description
`.شروع()`	—	Start the thread
`.انتظار(ختمی=null)`	—	Block until thread finishes (join)
`.چل_رہا()`	bool	Is the thread currently running?
`.شناخت()`	int	Thread ID (OS-level)

Static methods — جامد طریقے

Method	Returns	Description
`دھاگہ.موجودہ()`	Thread	Current running thread
`دھاگہ.گنتی()`	int	Number of active threads
`دھاگہ.سبھی()`	list	All currently active threads

دھاگہ_تالاب — Thread Pool

Manages a fixed pool of worker threads. Best for I/O-bound work.

اردو: دھاگہ تالاب (thread pool) مقررہ تعداد میں کارکن دھاگے سنبھالتا ہے۔ یہ I/O پابند کاموں جیسے نیٹ ورک اور فائل آپریشن کے لیے بہترین ہے۔

Constructor

متغیر تالاب = نیا دھاگہ_تالاب(کارکن=4)

Methods — طریقے

Method	Returns	Description
`.جمع_کرو(fn, *args)`	Future	Submit task; returns a future you can `.نتیجہ()`
`.غیر_متزامن_جمع(fn, *args)` async	result	Submit and await result
`.نقشہ(fn, آئٹمز)`	list	Apply fn to each item, collect results
`.بند(انتظار=سچ)`	—	Shut down pool (wait for running tasks if انتظار=سچ)

عمل_تالاب — Process Pool

Spawns separate OS processes. Bypasses the Python GIL for true CPU parallelism.

اردو: عمل تالاب (process pool) الگ OS عمل (processes) چلاتا ہے۔ یہ Python کے GIL کو نظرانداز کرتا ہے اور CPU پابند کاموں میں حقیقی متوازی عمل (parallelism) دیتا ہے۔

Constructor

متغیر تالاب = نیا عمل_تالاب(کارکن=null)

null uses os.cpu_count() workers.

Methods — طریقے

Method	Returns	Description
`.جمع_کرو(fn, *args)`	Future	Submit a task
`.نقشہ(fn, آئٹمز)`	list	Apply fn to each item in separate processes
`.بند()`	—	Shutdown pool

تالہ — Lock

Mutual exclusion to protect shared state.

اردو: تالہ (lock) مشترکہ حالت (shared state) کی حفاظت کے لیے باہمی اخراج (mutual exclusion) فراہم کرتا ہے۔ ایک وقت میں صرف ایک دھاگہ تالہ لے سکتا ہے۔

Constructor

متغیر ق = نیا تالہ(دوبارہ=جھوٹ)

Set دوبارہ=سچ for a reentrant lock (the same thread can acquire it multiple times).

Methods — طریقے

Method	Returns	Description
`.قبضہ(ختمی=-1)`	bool	Acquire lock; -1 = wait forever; returns false on timeout
`.چھوڑو()`	—	Release lock

Acquire / Release pattern

متغیر تل = نیا تالہ()
تل.قبضہ()
// تحفظ شدہ کوڈ
تل.چھوڑو()

واقعہ — Event

Thread synchronisation via signal/wait.

اردو: واقعہ (event) دھاگوں کے درمیان اشارہ دینے اور انتظار کرنے کے لیے ہم آہنگی فراہم کرتا ہے۔

Methods — طریقے

Method	Description
`.مقرر()`	Set the event (signal all waiters)
`.صاف()`	Clear the event
`.انتظار(ختمی=null)`	Block until event is set
`.لگا_ہوا()`	Return `سچ` if currently set

Examples — مثالیں

Example 1 — Parallel download (Thread Pool)

اردو: مثال ۱ — دھاگہ تالاب سے متوازی فائل ڈاؤن لوڈ

درآمد { دھاگہ_تالاب } سے "اردو/دھاگہ"
درآمد { کرل } سے "اردو/کرل"

متغیر http = نیا کرل()

فنکشن فائل_ڈاؤن_لوڈ(url, نام) {
    لکھو(`ڈاؤن لوڈ شروع: ${نام}`)
    متغیر جواب = http.حاصل(url)  // synchronous in thread
    لکھو(`مکمل: ${نام} — ${جواب.مواد.length} بائٹس`)
    واپس { نام, سائز: جواب.مواد.length }
}

متغیر فائلیں = [
    ["https://example.com/file1.pdf", "فائل1.pdf"],
    ["https://example.com/file2.pdf", "فائل2.pdf"],
    ["https://example.com/file3.pdf", "فائل3.pdf"],
    ["https://example.com/data.csv",  "ڈیٹا.csv"]
]

متغیر تالاب = نیا دھاگہ_تالاب(کارکن=4)

متغیر مستقبل_فہرست = []
کے_لیے (متغیر [url, نام] کا فائلیں) {
    متغیر م = تالاب.جمع_کرو(فائل_ڈاؤن_لوڈ, url, نام)
    مستقبل_فہرست.شامل(م)
}

// تمام نتائج اکٹھے کریں
کے_لیے (متغیر م کا مستقبل_فہرست) {
    متغیر نتیجہ = م.نتیجہ()
    لکھو(`✓ ${نتیجہ.نام}: ${نتیجہ.سائز} بائٹس`)
}

تالاب.بند()
لکھو("تمام فائلیں ڈاؤن لوڈ ہوئیں")

Example 2 — Producer / Consumer with Lock

اردو: مثال ۲ — تالہ (lock) کے ساتھ پیدا کنندہ / صارف نمونہ

درآمد { دھاگہ, تالہ } سے "اردو/دھاگہ"

متغیر قطار    = []
متغیر قطار_تالہ = نیا تالہ()

فنکشن پیدا_کنندہ() {
    کے_لیے (متغیر i کا حد(1, 11)) {
        قطار_تالہ.قبضہ()
        قطار.شامل(i)
        لکھو(`پیدا کیا: ${i}  (قطار: ${قطار.length})`)
        قطار_تالہ.چھوڑو()
        تاخیر_ہم_وقت(100)   // 100ms
    }

    // ختم کا اشارہ
    قطار_تالہ.قبضہ()
    قطار.شامل(خالی)
    قطار_تالہ.چھوڑو()
}

فنکشن صارف() {
    جبکہ (سچ) {
        قطار_تالہ.قبضہ()
        اگر (قطار.length > 0) {
            متغیر آئٹم = قطار.ہٹاؤ(0)
            قطار_تالہ.چھوڑو()
            اگر (آئٹم == خالی) {
                لکھو("صارف: ختم")
                ٹوٹنا
            }
            لکھو(`استعمال کیا: ${آئٹم}`)
        } ورنہ {
            قطار_تالہ.چھوڑو()
        }
        تاخیر_ہم_وقت(150)
    }
}

// دھاگے شروع کریں
متغیر ت1 = نیا دھاگہ(پیدا_کنندہ, نام="پیدا_کنندہ")
متغیر ت2 = نیا دھاگہ(صارف, نام="صارف")

ت1.شروع()
ت2.شروع()

ت1.انتظار()
ت2.انتظار()
لکھو("پروگرام مکمل")

Example 3 — Thread-safe counter

اردو: مثال ۳ — تالہ (lock) سے محفوظ گنتی کلاس (thread-safe counter)

درآمد { دھاگہ, دھاگہ_تالاب, تالہ } سے "اردو/دھاگہ"

// ─── گنتی کلاس ────────────────────────────
کلاس محفوظ_گنتی {
    تعمیر() {
        یہ.قدر  = 0
        یہ.تالہ = نیا تالہ()
    }

    بڑھاؤ(مقدار=1) {
        یہ.تالہ.قبضہ()
        یہ.قدر += مقدار
        یہ.تالہ.چھوڑو()
    }

    گھٹاؤ(مقدار=1) {
        یہ.تالہ.قبضہ()
        یہ.قدر -= مقدار
        یہ.تالہ.چھوڑو()
    }

    حاصل_کرو() {
        یہ.تالہ.قبضہ()
        متغیر نتیجہ = یہ.قدر
        یہ.تالہ.چھوڑو()
        واپس نتیجہ
    }
}

// ─── آزمائش ──────────────────────────────
متغیر گنتی = نیا محفوظ_گنتی()
متغیر تالاب = نیا دھاگہ_تالاب(کارکن=10)

// 1000 مرتبہ بیک وقت بڑھائیں
متغیر کام = []
کے_لیے (متغیر i کا حد(1000)) {
    کام.شامل(تالاب.جمع_کرو(گنتی.بڑھاؤ))
}

// انتظار کریں
کے_لیے (متغیر م کا کام) {
    م.نتیجہ()
}

لکھو("آخری گنتی:", گنتی.حاصل_کرو())   // 1000
تالاب.بند()

Example 4 — Event-based startup synchronisation

اردو: مثال ۴ — واقعہ (event) سے سرور شروع ہونے تک کلائنٹ کا انتظار

درآمد { دھاگہ, واقعہ } سے "اردو/دھاگہ"

متغیر تیار = نیا واقعہ()

فنکشن سرور_شروع_کرو() {
    لکھو("[سرور] شروع ہو رہا ہے...")
    تاخیر_ہم_وقت(2000)   // 2 سیکنڈ startup
    تیار.مقرر()
    لکھو("[سرور] تیار ہے")

    // چلتا رہو
    تاخیر_ہم_وقت(5000)
    لکھو("[سرور] بند ہو رہا ہے")
}

فنکشن کلائنٹ() {
    لکھو("[کلائنٹ] سرور کا انتظار...")
    تیار.انتظار()    // تیار ہونے تک رکو
    لکھو("[کلائنٹ] سرور تیار — کام شروع")
    // ... درخواستیں بھیجیں ...
    لکھو("[کلائنٹ] مکمل")
}

متغیر ت_سرور  = نیا دھاگہ(سرور_شروع_کرو, نام="سرور")
متغیر ت_کلائنٹ = نیا دھاگہ(کلائنٹ,        نام="کلائنٹ")

ت_سرور.شروع()
ت_کلائنٹ.شروع()

ت_سرور.انتظار()
ت_کلائنٹ.انتظار()

Example 5 — CPU-bound work with Process Pool

اردو: مثال ۵ — عمل تالاب (process pool) سے CPU پابند کام — اعداد اول کی گنتی

درآمد { عمل_تالاب } سے "اردو/دھاگہ"

فنکشن اعداد_اول_گنیں(حد) {
    متغیر گنتی = 0
    کے_لیے (متغیر n کا حد(2, حد)) {
        متغیر اول = سچ
        کے_لیے (متغیر i کا حد(2, Math.floor(Math.sqrt(n)) + 1)) {
            اگر (n % i == 0) {
                اول = جھوٹ
                ٹوٹنا
            }
        }
        اگر (اول) {
            گنتی += 1
        }
    }
    واپس { حد, گنتی }
}

// CPU کی تمام cores استعمال کریں
متغیر تالاب = نیا عمل_تالاب()   // cores کی تعداد کے برابر کارکن

متغیر حدود = [100000, 200000, 300000, 400000]
متغیر نتائج = تالاب.نقشہ(اعداد_اول_گنیں, حدود)

کے_لیے (متغیر نتیجہ کا نتائج) {
    لکھو(`0 سے ${نتیجہ.حد} تک: ${نتیجہ.گنتی} اعداد اول`)
}

تالاب.بند()

Example 6 — Parallel API calls with async pool

اردو: مثال ۶ — غیر متزامن دھاگہ تالاب سے متوازی API کالز

درآمد { دھاگہ_تالاب } سے "اردو/دھاگہ"
درآمد { کرل } سے "اردو/کرل"

متغیر http = نیا کرل()

غیر_متزامن فنکشن صارف_معلومات(id) {
    متغیر جواب = انتظار http.حاصل(`https://jsonplaceholder.typicode.com/users/${id}`)
    متغیر ڈیٹا = جواب.جے_سون()
    واپس { id, نام: ڈیٹا.name, ای_میل: ڈیٹا.email }
}

غیر_متزامن فنکشن تمام_صارفین_لوڈ_کریں() {
    متغیر تالاب = نیا دھاگہ_تالاب(کارکن=5)

    متغیر آئی_ڈیز = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    متغیر مستقبل_فہرست = []

    کے_لیے (متغیر id کا آئی_ڈیز) {
        متغیر م = تالاب.جمع_کرو(صارف_معلومات, id)
        مستقبل_فہرست.شامل(م)
    }

    لکھو("=" * 50)
    لکھو("تمام صارفین:")
    لکھو("=" * 50)

    کے_لیے (متغیر م کا مستقبل_فہرست) {
        متغیر صارف = م.نتیجہ()
        لکھو(`[${صارف.id}] ${صارف.نام} — ${صارف.ای_میل}`)
    }

    تالاب.بند()
}

انتظار تمام_صارفین_لوڈ_کریں()

Example 7 — Reentrant lock for nested calls

اردو: مثال ۷ — دوبارہ داخلہ تالہ (reentrant lock) سے گھونسلے دار کالز میں حفاظت

درآمد { تالہ } سے "اردو/دھاگہ"

کلاس درخت_نوڈ {
    تعمیر(قدر) {
        یہ.قدر  = قدر
        یہ.بچے  = []
        یہ.تالہ = نیا تالہ(دوبارہ=سچ)   // reentrant
    }

    شامل_کرو(بچہ_قدر) {
        یہ.تالہ.قبضہ()
        یہ.بچے.شامل(نیا درخت_نوڈ(بچہ_قدر))
        یہ.تالہ.چھوڑو()
    }

    گنتی() {
        یہ.تالہ.قبضہ()
        متغیر نتیجہ
        اگر (یہ.بچے.length == 0) {
            نتیجہ = 1
        } ورنہ {
            // reentrant — اسی دھاگے میں تالہ دوبارہ لے سکتے ہیں
            نتیجہ = 1 + یہ.بچے.reduce((s, b) => s + b.گنتی(), 0)
        }
        یہ.تالہ.چھوڑو()
        واپس نتیجہ
    }
}

متغیر جڑ = نیا درخت_نوڈ("جڑ")
جڑ.شامل_کرو("الف")
جڑ.شامل_کرو("ب")
جڑ.شامل_کرو("ج")

لکھو("نوڈز:", جڑ.گنتی())  // 4

Previous: Logging → | Next: Library Index ↑