queue ಬಳಸಿ Python ಥ್ರೆಡ್‌ಗಳ ನಡುವೆ ಪ್ರಾಕ್ಸಿ ಪೂಲ್ ಹಂಚಿಕೊಳ್ಳಿ

ಹಲವು ಥ್ರೆಡ್‌ಗಳು ಸಣ್ಣ ಪ್ರಾಕ್ಸಿ ಪೂಲ್ ಹಂಚಿಕೊಂಡಾಗ, ಯಾದೃಚ್ಛಿಕ ನಮೂದನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಎರಡು ಸಕ್ರಿಯ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಒಂದೇ ಪ್ರಾಕ್ಸಿ ನೀಡಬಹುದು. queue ಪ್ರಸ್ತುತ ಎರವಲು ಪಡೆಯಲು ಲಭ್ಯವಿರುವ ನಮೂದುಗಳನ್ನು ಇರಿಸಿಕೊಳ್ಳಬಹುದು:

from contextlib import contextmanager
from queue import Queue

available = Queue()
for endpoint in dict.fromkeys(proxy_urls):
    available.put(endpoint)

@contextmanager
def borrow_proxy():
    endpoint = available.get(timeout=5)
    try:
        yield endpoint
    finally:
        available.put(endpoint)

def process_url(url):
    with borrow_proxy() as endpoint:
        return fetch_one(url, endpoint)

ಕೆಲಸದ ಥ್ರೆಡ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು queue ಅನ್ನು ಒಮ್ಮೆ ನಿರ್ಮಿಸಿ. proxy_urls ಸಂಪೂರ್ಣ ಎಂಡ್‌ಪಾಯಿಂಟ್ URLಗಳನ್ನು ಹೊಂದಿದೆ. ಸಾರ್ವಜನಿಕ ಅಭ್ಯರ್ಥಿಗಳು ಉಚಿತ ಪ್ರಾಕ್ಸಿ ಪಟ್ಟಿಯಲ್ಲಿ ಲಭ್ಯವಿವೆ; fetch_one ಬೆಂಬಲಿಸುವ ಪ್ರೋಟೋಕಾಲ್ ಮತ್ತು URL ಸ್ವರೂಪವನ್ನು ಬಳಸಿ. ಇರುವ ಸಿಂಕ್ರೊನಸ್ fetch_one ಕಾರ್ಯವು ಹಿಂತಿರುಗುವ ಮೊದಲು ತನ್ನ ನೆಟ್‌ವರ್ಕ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ ಯಾವುದೇ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಮುಚ್ಚಬೇಕು. ಇಲ್ಲದಿದ್ದರೆ ಸಂಪರ್ಕವು ಇನ್ನೂ ಆ ಪ್ರಾಕ್ಸಿ ಬಳಸುತ್ತಿರುವಾಗಲೇ ಗುತ್ತಿಗೆ ಮುಗಿಯುತ್ತದೆ.

Queue.get ಒಂದು ಲಭ್ಯವಿರುವ ನಮೂದನ್ನು ಪರಮಾಣು ರೀತಿಯಲ್ಲಿ ತೆಗೆದುಹಾಕುತ್ತದೆ. ಖಾಲಿಯಾದ ಪೂಲ್ ಹಂಚಿದ ಧ್ವಜಗಳನ್ನು ಪದೇ ಪದೇ ಸ್ಕ್ಯಾನ್ ಮಾಡುವ ಬದಲು ಕಾಯುತ್ತದೆ. ಐದು ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಯಾವುದೇ ನಮೂದು ಬಾರದಿದ್ದರೆ, queue.Empty ಕರೆಯುವವರನ್ನು ತಲುಪುತ್ತದೆ; ಆ ಫಲಿತಾಂಶಕ್ಕೆ ಅಪ್ಲಿಕೇಶನ್‌ನ ಮರುಪ್ರಯತ್ನ, ವೈಫಲ್ಯ ಅಥವಾ ರದ್ದತಿ ನೀತಿಯನ್ನು ಆಯ್ಕೆ ಮಾಡಿ.

finally ಬ್ಲಾಕ್ ಯಶಸ್ಸು ಅಥವಾ ವಿನಾಯಿತಿಯ ನಂತರ ಸ್ವಾಧೀನಪಡಿಸಿಕೊಂಡ ನಮೂದನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ವಿಫಲವಾದ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಆರೋಗ್ಯಕರವಾಗಿದೆ ಎಂದು ಅದು ಘೋಷಿಸುವುದಿಲ್ಲ. ಕ್ವಾರಂಟೈನ್, ಬದಲಿ ಮತ್ತು ಕೂಲ್‌ಡೌನ್ ನೀತಿಗಳಿಗೆ ಸ್ಪಷ್ಟ ಮಾರ್ಗ ಬೇಕು, ತಾತ್ಕಾಲಿಕ ದೋಷ ಕಂಡ ಪ್ರತಿ ಪ್ರಾಕ್ಸಿಯನ್ನು ಸದ್ದಿಲ್ಲದೆ ಎಸೆಯುವ ಬದಲು.

ಒಂದೇ URL ಸ್ಟ್ರಿಂಗ್‌ಗಳ ನಕಲನ್ನು ತೆಗೆಯುವುದು queue ನಲ್ಲಿ ನಕಲಿ ನಮೂದುಗಳನ್ನು ತಡೆಯುತ್ತದೆ. ವಿಭಿನ್ನ URLಗಳು ಇನ್ನೂ ಒಂದೇ ಭೌತಿಕ ಪ್ರಾಕ್ಸಿ ಅಥವಾ ನಿರ್ಗಮನವನ್ನು ಸೂಚಿಸಬಹುದು; ಆ ಹಂಚಿದ ಸಂಪನ್ಮೂಲಕ್ಕೆ ಪ್ರತ್ಯೇಕತೆ ಅನ್ವಯವಾಗಬೇಕಿದ್ದರೆ ಅವನ್ನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಗುಂಪು ಮಾಡಿ. queue ಈ ಪ್ರಕ್ರಿಯೆಯ ಥ್ರೆಡ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ, ಬೇರೆ ಯಂತ್ರಗಳ ಕೆಲಸಗಾರರನ್ನಲ್ಲ.