મોટી પ્રોક્સી બેચ માટે 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 નથી.