വലിയ പ്രോക്സി ബാച്ചുകൾക്കായി Python 3.14 Executor.map buffersize

max_workers=8 പ്രവർത്തിക്കുന്ന ത്രെഡുകൾ പരിമിതപ്പെടുത്തുന്നു. എന്നാൽ വലിയ ഇൻപുട്ടിൽ ഓരോ എൻഡ്പോയിന്റിനും Future സൃഷ്ടിക്കുന്നതിൽ നിന്ന് വേറിട്ട സമർപ്പണ ലൂപ്പിനെ തടയുന്നില്ല.

Python 3.14 പരിമിതമായ മുൻകൂട്ടി-വായന ഓപ്ഷൻ ചേർക്കുന്നു:

from concurrent.futures import ThreadPoolExecutor

with ThreadPoolExecutor(max_workers=8) as executor:
    for result in executor.map(check_proxy, endpoints, buffersize=24):
        record_result(result)

check_proxy നെറ്റ്വർക്ക് സമയപരിധികളും ക്ലീനപ്പും ഉള്ള നിലവിലെ സിൻക്രണസ് പരിശോധനയാണ്; record_result അത് തിരികെ നൽകുന്ന നിരീക്ഷണം കൈകാര്യം ചെയ്യുന്നു. 8, 24 എന്ന മൂല്യങ്ങൾ ഉദാഹരണ ബജറ്റുകളാണ്. സൗജന്യ പ്രോക്സി പട്ടിക എൻഡ്പോയിന്റുകൾക്ക് പൊതു സ്ഥാനാർഥികൾ നൽകുന്നു; check_proxy ശരിയായ ഗതാഗതം ഉപയോഗിക്കാൻ ഓരോ വിലാസത്തിനൊപ്പവും അവയുടെ പ്രോട്ടോക്കോൾ സൂക്ഷിക്കുക.

സമർപ്പണ ബഫർ നിറയുമ്പോൾ, ഫലങ്ങൾ നൽകുന്നതുവരെ map ഇറ്ററബിളിന്റെ ഉപഭോഗം താൽക്കാലികമായി നിർത്തുന്നു. ഇത് ജനറേറ്ററുകൾക്കും ബാധകമാണ്.

map ഇപ്പോഴും ഇൻപുട്ട് ക്രമത്തിൽ നൽകുന്നു: സാവധാനമുള്ള ആദ്യ പരിശോധന പൂർത്തിയായ പിന്നീടുള്ള ഫലങ്ങൾ പിടിച്ചുവയ്ക്കുകയും കൂടുതൽ ഇൻപുട്ട് വൈകിപ്പിക്കുകയും ചെയ്യാം. പൂർത്തീകരണ ക്രമത്തിൽ പ്രോസസ്സ് ചെയ്യാൻ, പൂർത്തിയാകുമ്പോൾ നിറയ്ക്കുന്ന വ്യക്തമായി പരിമിതപ്പെടുത്തിയ futures കൂട്ടം ഉപയോഗിക്കുക.

ബാച്ച് ഫലങ്ങൾ നൽകുന്നത് തുടരേണ്ടതുണ്ടെങ്കിൽ പ്രതീക്ഷിക്കുന്ന നെറ്റ്വർക്ക് പരാജയങ്ങൾ പരിശോധനയ്ക്കുള്ളിൽ കൈകാര്യം ചെയ്യുക. ആ ഇനം എടുക്കുമ്പോൾ കൈകാര്യം ചെയ്യാത്ത ഒരു എക്സെപ്ഷൻ ഉയരുന്നു. ThreadPoolExecutor-ന്റെ chunksize ഈ സമർപ്പണ ബജറ്റ് നൽകുന്നില്ല, പഴയ Python പതിപ്പുകൾക്ക് buffersize ഇല്ല.