పెద్ద ప్రాక్సీ బ్యాచ్‌ల కోసం 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 లేదు.