Requests pool_maxsize-നേക്കാൾ കൂടുതൽ കണക്ഷനുകൾ തുറക്കുന്നത് എന്തുകൊണ്ട്

പരിമിതമായ ഒരു പൂളിന് pool_block ഉപയോഗിക്കുക, കൂടാതെ പരിധി പ്രോക്സി വഴിയുള്ള എല്ലാ ട്രാഫിക്കും ഉൾക്കൊള്ളേണ്ടതുണ്ടെങ്കിൽ ആപ്ലിക്കേഷൻ തലത്തിലുള്ള ബജറ്റ് ചേർക്കുക.

സ്വതവേയുള്ള pool_block=False ഉള്ളപ്പോൾ, pool_maxsize ഒരു പൂളിൽ സൂക്ഷിക്കുന്ന കണക്ഷനുകളെ പരിമിതപ്പെടുത്തുന്നു, ഒരേസമയത്തുള്ള എല്ലാ കണക്ഷനുകളെയല്ല. Requests അധിക കണക്ഷനുകൾ സൃഷ്ടിച്ച് പിന്നീട് അവ ഉപേക്ഷിച്ചേക്കാം.

നിലവിലുള്ള ഒരു സെഷന്റെ HTTPS അഭ്യർത്ഥനകൾ ഉപയോഗിക്കുന്ന പരിമിതമായ പൂളിന്:

from requests.adapters import HTTPAdapter

adapter = HTTPAdapter(
    pool_connections=10,
    pool_maxsize=4,
    pool_block=True,
)
session.mount("https://", adapter)

മൗണ്ട് HTTPS ലക്ഷ്യ URL-കൾ തിരഞ്ഞെടുക്കുന്നു. HTTP അഭ്യർത്ഥനകൾ http://-ന് കീഴിൽ മൗണ്ട് ചെയ്ത അഡാപ്റ്റർ ഉപയോഗിക്കുന്നു.

ഇൻപുട്ട്ഇത് എന്താണ് നിയന്ത്രിക്കുന്നത്
pool_connectionsമാനേജർ എത്ര പൂളുകൾ കാഷ് ചെയ്യുന്നു
pool_maxsizeഒരു പൂളിനുള്ളിലെ കണക്ഷനുകൾ
pool_block=Trueഅധികമൊന്ന് സൃഷ്ടിക്കുന്നതിനുപകരം പൂൾ കണക്ഷനായി കാത്തിരിക്കുക

Requests പ്രോക്സി URL അനുസരിച്ച് പ്രോക്സി മാനേജർമാരെയും കാഷ് ചെയ്യുന്നു. ഈ മൂല്യങ്ങൾ മാറിവരുന്ന പ്രോക്സികളുടെയും ലക്ഷ്യങ്ങളുടെയും പട്ടികയിലുടനീളം ഒരു മൊത്ത പരിധി രൂപപ്പെടുത്തുന്നില്ല. എല്ലാ ജോലിയും ഒരു മധ്യവർത്തിയിലൂടെ കടന്നുപോകണം എന്നതാണ് ആവശ്യമെങ്കിൽ ആപ്ലിക്കേഷൻ തലത്തിലുള്ള സമവർത്തി ബജറ്റ് ഉപയോഗിക്കുക.

ബ്ലോക്കിംഗ് പ്രതികരണങ്ങൾ വിടുവിക്കുന്നത് അനിവാര്യമാക്കുന്നു: ബോഡികൾ ഉപഭോഗിക്കുകയോ സ്ട്രീമിംഗ് പ്രതികരണങ്ങൾ അടയ്ക്കുകയോ ചെയ്യുക എന്നാൽ കാത്തിരിക്കുന്ന ജോലിക്ക് മുന്നോട്ടുപോകാം. കാണിച്ചിരിക്കുന്ന ക്രമീകരണത്തിൽ Requests-ന്റെ അഡാപ്റ്റർ ഈ പൂൾ-കാത്തിരിപ്പിന് പ്രത്യേക ടൈംഔട്ട് നൽകുന്നില്ല.

അനുബന്ധ ലേഖനങ്ങൾ