thread pool ਕੀ ਹੈ? ਇੱਕ ਕਿਉਂ ਵਰਤੀਏ, ਅਤੇ ਤੁਸੀਂ ਇਸ ਨੂੰ ਕਿਵੇਂ size ਕਰਦੇ ਹੋ?

Question

IT Interview Practice · Accepted Answer

**ਇੱਕ thread pool ਦੁਬਾਰਾ-ਵਰਤੋਂਯੋਗ worker threads ਦਾ ਇੱਕ ਸਥਿਰ ਸੈੱਟ ਹੈ ਜੋ ਇੱਕ ਸਾਂਝੀ work queue ਤੋਂ tasks ਖਿੱਚਦੇ ਹਨ।** ਇਹ ਹਰ task ਲਈ ਇੱਕ thread ਬਣਾਉਣ ਦੀ ਲਾਗਤ ਤੋਂ ਬਚਦਾ ਹੈ ਅਤੇ concurrent threads ਦੀ ਗਿਣਤੀ ਨੂੰ ਸੀਮਿਤ ਕਰਦਾ ਹੈ।

## ਇੱਕ ਕਿਉਂ ਵਰਤੀਏ

Threads ਬਣਾਉਣਾ ਅਤੇ ਨਸ਼ਟ ਕਰਨਾ ਮਹਿੰਗਾ ਹੈ (stack allocation, OS scheduling setup), ਅਤੇ ਬੇਹੱਦ thread ਬਣਾਉਣਾ memory ਨੂੰ ਥਕਾ ਦਿੰਦਾ ਹੈ ਅਤੇ context-switch thrashing ਪੈਦਾ ਕਰਦਾ ਹੈ। ਇੱਕ pool creation ਲਾਗਤ ਨੂੰ ਵੰਡ ਦਿੰਦਾ ਹੈ ਅਤੇ concurrency ਨੂੰ ਸੀਮਿਤ ਕਰਦਾ ਹੈ।

```text
tasks →  [ work queue ]  →  worker 1
                            worker 2   (N fixed workers pull & run)
                            worker 3
```

## ਉਦਾਹਰਨ

```python
from concurrent.futures import ThreadPoolExecutor
with ThreadPoolExecutor(max_workers=8) as pool:
    futures = [pool.submit(handle, req) for req in requests]
    # 8 threads process the queue; extras wait their turn
```

## Sizing

- **CPU-bound** ਕੰਮ: pool size ≈ cores ਦੀ ਗਿਣਤੀ। cores ਤੋਂ ਵੱਧ threads ਸਿਰਫ਼ ਬਿਨਾਂ parallelism ਲਾਭ ਦੇ context-switch overhead ਜੋੜਦੇ ਹਨ।
- **I/O-bound** ਕੰਮ: ਵੱਡਾ size ਕਰੋ, ਲਗਭਗ `cores × (1 + wait_time / compute_time)`, ਕਿਉਂਕਿ threads ਜ਼ਿਆਦਾਤਰ ਸਮਾਂ blocked ਰਹਿੰਦੇ ਹਨ ਅਤੇ overlap ਕਰ ਸਕਦੇ ਹਨ।
- **queue ਨੂੰ ਵੀ ਸੀਮਿਤ ਕਰੋ**: ਇੱਕ ਬੇਹੱਦ queue overload ਨੂੰ ਲੁਕਾਉਂਦੀ ਹੈ ਅਤੇ OOM ਵੱਲ ਲੈ ਜਾਂਦੀ ਹੈ; ਇੱਕ rejection policy (drop, block, ਜਾਂ shed) ਵਾਲੀ ਇੱਕ bounded queue backpressure ਲਾਗੂ ਕਰਦੀ ਹੈ।

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

Pools servers ਅਤੇ executors ਦੀ ਰੀੜ੍ਹ ਦੀ ਹੱਡੀ ਹਨ। ਗ਼ਲਤ sizing ਇੱਕ ਕਲਾਸਿਕ performance bug ਹੈ: ਬਹੁਤ ਘੱਟ threads CPU ਨੂੰ ਘੱਟ-ਵਰਤਦੇ ਹਨ; ਬਹੁਤ ਜ਼ਿਆਦਾ thrashing ਅਤੇ memory pressure ਪੈਦਾ ਕਰਦੇ ਹਨ। pool size ਨੂੰ workload ਕਿਸਮ (CPU ਬਨਾਮ I/O) ਨਾਲ ਮੇਲਣਾ ਅਤੇ queue ਨੂੰ ਸੀਮਿਤ ਕਰਨਾ system ਨੂੰ load ਹੇਠ ਸਥਿਰ ਰੱਖਦਾ ਹੈ।

ਇੱਕ ਕਿਉਂ ਵਰਤੀਏ

ਉਦਾਹਰਨ

Sizing

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ