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 ରେ ସମ୍ପୂର୍ଣ୍ଣ endpoint URL ଅଛି। ସାର୍ବଜନୀନ ପ୍ରାର୍ଥୀ ମାଗଣା ପ୍ରକ୍ସି ତାଲିକାରେ ଉପଲବ୍ଧ; fetch_one ସମର୍ଥନ କରୁଥିବା ପ୍ରୋଟୋକଲ୍ ଏବଂ URL ଫର୍ମାଟ୍ ବ୍ୟବହାର କରନ୍ତୁ। ବିଦ୍ୟମାନ ସିଙ୍କ୍ରୋନସ୍ fetch_one ଫଙ୍କସନ୍ ଫେରିବା ପୂର୍ବରୁ ଏହାର ନେଟୱାର୍କ ଅପରେସନ୍ ସମାପ୍ତ କରି ଯେକୌଣସି ପ୍ରତିକ୍ରିୟା ବନ୍ଦ କରିବା ଆବଶ୍ୟକ। ଅନ୍ୟଥା ସଂଯୋଗ ଏବେ ମଧ୍ୟ ସେହି ପ୍ରକ୍ସି ବ୍ୟବହାର କରୁଥିବାବେଳେ ଲିଜ୍ ଶେଷ ହେବ।

Queue.get ଏକ ଉପଲବ୍ଧ ଏଣ୍ଟ୍ରିକୁ ପରମାଣୁ ଭାବରେ ଅପସାରଣ କରେ। ଶେଷ ହୋଇଥିବା ପୁଲ୍ ବାରମ୍ବାର ସେୟାର୍ଡ ଫ୍ଲାଗ୍ ସ୍କାନ୍ କରିବା ପରିବର୍ତ୍ତେ ଅପେକ୍ଷା କରେ। ଯଦି ପାଞ୍ଚ ସେକେଣ୍ଡ ମଧ୍ୟରେ କୌଣସି ଏଣ୍ଟ୍ରି ନଆସେ, queue.Empty କଲର୍ ପାଖରେ ପହଞ୍ଚେ; ସେହି ଫଳାଫଳ ପାଇଁ ଆପ୍ଲିକେସନ୍ର ପୁନଃଚେଷ୍ଟା, ବିଫଳତା କିମ୍ବା ବାତିଲ୍ ନୀତି ବାଛନ୍ତୁ।

finally ବ୍ଲକ୍ ସଫଳତା କିମ୍ବା ବ୍ୟତିକ୍ରମ ପରେ ଅର୍ଜିତ ଏଣ୍ଟ୍ରି ଫେରାଇଦିଏ। ଏହା ଘୋଷଣା କରେ ନାହିଁ ଯେ ବିଫଳ endpoint ସୁସ୍ଥ ଅଛି। କ୍ୱାରାଣ୍ଟିନ୍, ପ୍ରତିସ୍ଥାପନ ଏବଂ କୁଲଡାଉନ୍ ନୀତି ପାଇଁ ସ୍ପଷ୍ଟ ପଥ ଆବଶ୍ୟକ, ଅସ୍ଥାୟୀ ତ୍ରୁଟି ଦେଖୁଥିବା ପ୍ରତ୍ୟେକ ପ୍ରକ୍ସିକୁ ଚୁପଚାପ୍ ଫିଙ୍ଗିବା ପରିବର୍ତ୍ତେ।

ସମାନ URL ଷ୍ଟ୍ରିଙ୍ଗ୍ର ନକଲ ହଟାଇବା queue ରେ ଦୁଇଥର ଏଣ୍ଟ୍ରି ରୋକେ। ଭିନ୍ନ URL ଏବେ ମଧ୍ୟ ସମାନ ଭୌତିକ ପ୍ରକ୍ସି କିମ୍ବା ଏକ୍ଜିଟ୍କୁ ସୂଚାଇପାରେ; ଯଦି ସେହି ସେୟାର୍ଡ ସମ୍ପଦ ଉପରେ ଏକଚାଟିଆ ଲାଗୁ ହେବା ଉଚିତ, ସେଗୁଡ଼ିକୁ ଉଦ୍ଦେଶ୍ୟମୂଳକ ଭାବରେ ଏକତ୍ର କରନ୍ତୁ। queue ଏହି ପ୍ରକ୍ରିୟାର ଥ୍ରେଡ୍ଗୁଡ଼ିକୁ ସମନ୍ୱୟ କରେ, ଅନ୍ୟ ମେସିନର ୱାର୍କରମାନଙ୍କୁ ନୁହେଁ।