# Độ đồng thời và lưu lượng qua proxy dân cư

> Số lượng yêu cầu đồng thời chạy qua proxy dân cư: Luật Little, giới hạn theo host, mã concurrency linh hoạt và GB trên giờ.

- URL: https://crawlrelay.com/vi/docs/concurrency/
- Cập nhật lần cuối: 2026-10-13
- Publisher: CrawlRelay (https://crawlrelay.com)

Cổng thanh toán tính theo GB, không theo luồng, nên giới hạn thực tế là từng trang web mục tiêu. Định kích thước độ đồng thời dựa trên lưu lượng bạn cần, giới hạn theo mỗi máy chủ, và để các phản hồi cho bạn biết khi nào cần chậm lại.

**Trả lời nhanh — Tôi có thể chạy bao nhiêu yêu cầu đồng thời qua proxy dân cư?**

Tối đa tùy từng trang web mục tiêu chấp nhận: **CrawlRelay** tính phí lưu lượng dân cư theo GB (0,50 US$/GB từ 50 GB), không tính theo luồng hay kết nối. Định kích thước độ đồng thời theo định luật Little, số yêu cầu đang chạy = trang trên giây × giây cho mỗi trang, sau đó giới hạn theo máy chủ, bắt đầu từ 2 đến 4. Giảm xuống khi xuất hiện phản hồi 429 hoặc 503. Thanh toán bằng crypto, không cần KYC.

## Độ đồng thời nhìn tổng quan

| Thuộc tính | Giá trị |
| --- | --- |
| Thanh toán | Theo GB lưu lượng; không tính luồng hay kết nối |
| Quy tắc kích thước | Số yêu cầu đang chạy = lưu lượng × độ trễ (định luật Little) |
| Điểm bắt đầu mỗi máy chủ | 2–4 yêu cầu song song; 1 yêu cầu kèm chậm trễ cho trang nhỏ |
| Dấu hiệu cần chậm lại | 429, 503, thời gian phản hồi tăng, trang thách thức |
| Tính toán băng thông | Trang trên giây × byte mỗi trang × 3.600 = byte mỗi giờ |
| Phản hồi trung bình của residential proxy | 0,93 giây trên mạng proxy, 3,21 giây trên trang thật (Proxyway 2026) |

## Làm thế nào để tôi xác định độ đồng thời từ lưu lượng cần?

Dùng định luật Little: số yêu cầu đang chạy bằng tỉ lệ bạn muốn nhân với thời gian mỗi yêu cầu. Nghiên cứu thị trường Proxyway 2026 đo trung bình 3,21 giây mỗi yêu cầu trên trang thật qua proxy dân cư, nên lập kế hoạch với 2 đến 4 giây cho trang thật, không dùng số liệu dưới 1 giây của mạng riêng.

| Mục tiêu | Thời gian mỗi yêu cầu | Yêu cầu đang chạy |
| --- | --- | --- |
| 5 trang một giây | 2 giây | 10 |
| 20 trang một giây | 2 giây | 40 |
| 20 trang một giây | 4 giây | 80 |
| 100 trang một giây | 3 giây | 300 |

Sau đó phân bổ các yêu cầu đó qua các máy chủ. Bốn mươi yêu cầu đang chạy qua 200 trang là nhẹ nhàng; bốn mươi yêu cầu trên một trang nhỏ là bài kiểm tra tải mà trang đó không đồng ý.

## Lưu lượng băng thông dùng cho mức lưu lượng đó là bao nhiêu?

Nhân trang trên giây với byte mỗi trang. Ở mức 20 trang HTML một giây và 50 KB mỗi trang, crawl di chuyển 1 MB mỗi giây, tương đương 3,6 GB mỗi giờ và khoảng 86 GB mỗi ngày. Ở 2 MB cho mỗi trang render, tốc độ tương tự di chuyển 40 MB mỗi giây.

Nhân kết quả với giá mỗi GB trong kế hoạch của bạn, 0,50 US$/GB từ 50 GB ở CrawlRelay, để tính chi phí theo giờ. [Hướng dẫn tính băng thông](https://crawlrelay.com/vi/guides/bandwidth-calculator/) cung cấp trọng lượng trang điển hình theo loại trang.

## Giới hạn mỗi máy chủ nào tôi nên bắt đầu?

| Mục tiêu | Yêu cầu song song trên mỗi máy chủ | Khoảng cách giữa các yêu cầu | Ghi chú |
| --- | --- | --- | --- |
| Trang nhỏ (blog, cửa hàng địa phương) | 1 | 2–5 giây | Tuân thủ `Crawl-delay` trong robots.txt nếu có |
| Trang web trung bình | 2–4 | 0,5–2 giây | Theo dõi thời gian phản hồi; giảm tải khi thời gian phản hồi tăng gấp đôi |
| Nền tảng lớn có CDN | 4–16 | AutoThrottle hoặc thích ứng | Chỉ tăng khi tỉ lệ 429 và 5xx giữ ổn định |
| API công khai | Giới hạn đã được ghi chép | Theo tài liệu | Sử dụng khóa API và giới hạn mà nhà cung cấp cung cấp cho bạn |

## Làm thế nào để tự động điều chỉnh số luồng?

Sử dụng phương pháp tăng cộng và giảm nhân, quy tắc TCP dùng cho tình trạng tắc nghẽn mạng: tăng một khe sau một chuỗi phản hồi sạch, giảm một nửa giới hạn khi gặp 429 hoặc 503. Bộ giới hạn dưới đây giữ một giới hạn cho mỗi host, tạm dừng mọi yêu cầu tới host đó trong thời gian trễ `Retry-After`, thử lại một lần và không vượt quá giới hạn tối đa bạn đặt. Lỗi mạng được trả về dưới dạng giá trị, nên một lần timeout không dừng toàn bộ tiến trình.

*Python asyncio: giới hạn thích ứng với httpx*

```python
import asyncio
import random
from urllib.parse import urlsplit

import httpx

PROXY = "http://USERNAME-country-us:PASSWORD@gw.crawlrelay.com:7777"


class AdaptiveLimit:
    """One per host: +1 slot after 20 clean responses, halve on 429/503, pause for Retry-After."""

    def __init__(self, start=2, low=1, high=16):
        self.limit, self.low, self.high = start, low, high
        self.in_flight, self.clean = 0, 0
        self.pause_until = 0.0
        self.cond = asyncio.Condition()

    async def __aenter__(self):
        loop = asyncio.get_running_loop()
        while True:
            async with self.cond:
                await self.cond.wait_for(lambda: self.in_flight < self.limit)
                delay = self.pause_until - loop.time()
                if delay <= 0:
                    self.in_flight += 1
                    return self
            await asyncio.sleep(delay)  # the host asked for a pause: wait outside the lock

    async def __aexit__(self, *exc):
        async with self.cond:
            self.in_flight -= 1
            self.cond.notify_all()

    def record(self, status, retry_after=None):
        if status in (429, 503):
            self.limit, self.clean = max(self.low, self.limit // 2), 0
            wait = int(retry_after) if retry_after and retry_after.isdigit() else 5 + random.random()
            now = asyncio.get_running_loop().time()
            self.pause_until = max(self.pause_until, now + wait)
        elif status < 400:
            self.clean += 1
            if self.clean >= 20 and self.limit < self.high:
                self.limit, self.clean = self.limit + 1, 0


gates = {}


def gate_for(url):
    host = urlsplit(url).hostname
    if host not in gates:
        gates[host] = AdaptiveLimit()
    return gates[host]


async def fetch(client, url, attempts=2):
    gate = gate_for(url)
    status = None
    for _ in range(attempts):
        try:
            async with gate:
                r = await client.get(url)
        except httpx.HTTPError as exc:
            return "error: %s" % type(exc).__name__
        status = r.status_code
        gate.record(status, r.headers.get("Retry-After"))
        if status not in (429, 503):
            break  # the retry, if any, waits for the host's pause in __aenter__
    return status


async def main(urls):
    timeout = httpx.Timeout(30.0, connect=10.0)
    async with httpx.AsyncClient(proxy=PROXY, timeout=timeout) as client:
        print(await asyncio.gather(*(fetch(client, u) for u in urls)))
    print({host: gate.limit for host, gate in gates.items()})


asyncio.run(main(["https://example.com/"] * 10))
```

## Ngoài mục tiêu, điều gì khiến việc crawl qua proxy chậm lại?

- **Bắt tay TLS.** Mỗi kết nối mới cho mỗi yêu cầu, cần thiết khi mỗi lần yêu cầu dùng một IP mới, sẽ thêm một lần bắt tay với trang web mỗi lần. Giữ phiên sticky với keep-alive cho các trang của một trang web khi sự đa dạng IP không quan trọng.
- **Kết nối thoát chậm.** Proxy dân cư và proxy di động 4G là các liên kết thực tế tại nhà và mạng di động. Dùng thời gian chờ và thử lại kết nối mới thay vì chờ lâu.
- **Nhắm mục tiêu hẹp.** Một thành phố nhỏ hoặc một ASN cụ thể có ít điểm thoát hơn một quốc gia. Chỉ tập trung vào những nơi dữ liệu thay đổi.
- **Kết xuất.** Trình duyệt headless tốn nhiều CPU, bộ nhớ và băng thông mỗi trang hơn client HTTP. Chỉ kết xuất các trang cần JavaScript.
- **DNS.** Với `socks5h://` hoặc cổng HTTP, DNS được phân giải tại điểm thoát; bạn không cần bộ nhớ đệm DNS cục bộ cho các host mục tiêu.

## Câu hỏi về độ đồng thời

### CrawlRelay có giới hạn số luồng hay kết nối không?

Các gói tính phí theo GB dữ liệu, không tính theo luồng, kết nối hay yêu cầu, và các gói đã công bố không đặt giới hạn số luồng. Giới hạn thực tế là khả năng chịu tải của mỗi mục tiêu và máy của bạn. Nếu bạn dự định crawl quy mô lớn, hãy liên hệ với support@crawlrelay.com trước để chúng tôi kiểm tra phạm vi nhắm mục tiêu của bạn.

### Tại sao crawl của tôi lại chậm hơn khi tôi tăng số luồng?

Thông thường do mục tiêu bắt đầu giới hạn bạn: thời gian phản hồi tăng, xuất hiện phản hồi 429 hoặc 503, và việc thử lại làm tăng tải. Nguyên nhân phổ biến khác là máy của bạn hết CPU hoặc ổ cắm mạng, đặc biệt khi dùng trình duyệt headless. Đo độ trễ và tỉ lệ lỗi từng host trước khi thêm luồng.

### Một kết nối cho mỗi yêu cầu có chậm hơn keep-alive không?

Có, mất thêm một lần bắt tay TCP và TLS cho mỗi yêu cầu, thường là vài trăm mili giây qua proxy dân cư. Đó là chi phí cho mỗi yêu cầu dùng một IP mới. Với nhiều trang của cùng một site khi IP không quan trọng, phiên sticky với keep-alive nhanh hơn và dùng ít băng thông hơn.

### Làm sao tôi tuân thủ crawl-delay trong robots.txt khi crawl đồng thời?

Phân tích robots.txt một lần cho mỗi host, lưu cache tối đa 24 giờ như RFC 9309 đề xuất, và biến giá trị `Crawl-delay` thành khoảng cách tối thiểu giữa các yêu cầu trên mỗi host với độ đồng thời 1. Python's `urllib.robotparser` cung cấp điều này qua `crawl_delay()`.

**Mở rộng theo giá mỗi GB** 0,50 US$/GB từ 50 GB đến 1 TB, dữ liệu không bao giờ hết hạn. [Xem giá](https://crawlrelay.com/vi/pricing/) · [Máy tính băng thông](https://crawlrelay.com/vi/guides/bandwidth-calculator/)

---

CrawlRelay: CrawlRelay là dịch vụ proxy dân cư xoay vòng và proxy di động 4G/5G dành cho nhà phát triển, hỗ trợ scrapers và pipeline dữ liệu AI: traffic trả tiền theo nhu cầu không hết hạn từ 0,50 US$/GB, thanh toán bằng crypto, không cần tải lên ID. Không cần KYC — không cần ID, không chụp selfie, không giấy tờ.