ક્યૂ સાથે Python થ્રેડો વચ્ચે પ્રોક્સી પૂલ શેર કરો

જ્યારે ઘણા થ્રેડો નાનો પ્રોક્સી પૂલ શેર કરે છે, ત્યારે રેન્ડમ એન્ટ્રી પસંદ કરવાથી બે સક્રિય ઓપરેશનને એક જ પ્રોક્સી મળી શકે છે. ક્યૂ હાલમાં ઉધાર લેવા ઉપલબ્ધ એન્ટ્રીઓ રાખી શકે છે:

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)

વર્કર થ્રેડો શરૂ કરતા પહેલા ક્યૂ એક વાર બનાવો. proxy_urls માં સંપૂર્ણ એન્ડપોઇન્ટ URL છે. જાહેર ઉમેદવારો મફત પ્રોક્સી સૂચિમાં ઉપલબ્ધ છે; fetch_one જે પ્રોટોકોલ અને URL ફોર્મેટને સપોર્ટ કરે છે તે વાપરો. હાલનું સિંક્રોનસ fetch_one ફંક્શન પરત ફરતા પહેલા તેનું નેટવર્ક ઓપરેશન પૂર્ણ કરીને કોઈપણ પ્રતિસાદ બંધ કરવો જોઈએ. અન્યથા કનેક્શન હજી તે પ્રોક્સી વાપરતું હોય ત્યારે લીઝ સમાપ્ત થશે.

Queue.get એક ઉપલબ્ધ એન્ટ્રીને અણુ રીતે દૂર કરે છે. ખાલી થયેલ પૂલ વારંવાર શેર કરેલા ફ્લેગ સ્કેન કરવાને બદલે રાહ જુએ છે. જો પાંચ સેકન્ડમાં કોઈ એન્ટ્રી ન આવે, તો queue.Empty કૉલર સુધી પહોંચે છે; તે પરિણામ માટે એપ્લિકેશનની ફરી પ્રયાસ, નિષ્ફળતા અથવા રદ નીતિ પસંદ કરો.

finally બ્લોક સફળતા અથવા અપવાદ પછી મેળવેલ એન્ટ્રી પરત કરે છે. તે જાહેર કરતું નથી કે નિષ્ફળ એન્ડપોઇન્ટ સ્વસ્થ છે. ક્વોરેન્ટાઇન, રિપ્લેસમેન્ટ અને કૂલડાઉન નીતિઓને સ્પષ્ટ માર્ગની જરૂર છે, કામચલાઉ ભૂલ જોયેલા દરેક પ્રોક્સીને ચૂપચાપ કાઢી નાખવાને બદલે.

સમાન URL શબ્દમાળાઓને ડુપ્લિકેટ દૂર કરવાથી ક્યૂમાં નકલી એન્ટ્રી અટકે છે. અલગ URL હજી પણ એક જ ભૌતિક પ્રોક્સી અથવા એક્ઝિટ તરફ નિર્દેશ કરી શકે છે; જો તે શેર કરેલ સંસાધન પર વિશિષ્ટતા લાગુ પડવી જોઈએ તો તેમને જાણી જોઈને જૂથબદ્ધ કરો. ક્યૂ આ પ્રક્રિયામાંના થ્રેડોનું સમન્વયન કરે છે, અન્ય મશીનોના વર્કર્સનું નહીં.