ದೊಡ್ಡ ಪ್ರಾಕ್ಸಿ ಬ್ಯಾಚ್‌ಗಳಿಗಾಗಿ 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 ಇಲ್ಲ.