पर्ल में मल्टीथ्रेडिंग, या मैंने वेयरहाउस 13 के फिल्मांकन के बारे में एक वीडियो कैसे देखा

यह सब इस तथ्य से शुरू हुआ कि मैं एक वीडियो में आया था जिसने मेरे पसंदीदा टीवी शो, वेयरहाउस 13 में से एक को फिल्माने की बात की थी:
www.aoltv.com/2009/07/10/behind-the-scenes-of-warehouse-13

कूल स्टीमपंक सामान, पारस्परिक सहायता और दोस्ती के बारे में एक कहानी, और एक हल्का जादुई वातावरण जो आपको ग्रे रोजमर्रा की जिंदगी से दूर ले जाता है - यही मैं इस श्रृंखला के बारे में पसंद करता हूं। सामान्य तौर पर, मुझे फिल्म से कम दिलचस्पी नहीं है, यह देखने के लिए होता है कि यह फिल्म कैसे बनी है।

लेकिन, जैसा कि AOL TV वेबसाइट पर प्रथागत है, वीडियो केवल अमेरिकी निवासियों के लिए उपलब्ध था। ऐसे प्रतिबंध क्यों लगाए - मैं समझ नहीं पा रहा हूं वे कहाँ और किस मद में मदमस्त हैं, यह स्पष्ट नहीं है।
लेकिन ऐसी हरकत मुझे रोक नहीं पाई।

जाहिर है, एक प्रॉक्सी सर्वर को खोजने के लिए आवश्यक था, जिसके पीछे मैं aoltv साइट के लिए एक वास्तविक एमरिकोस जैसा दिखूंगा। और इसके लिए पहले परदे के पीछे की सूची ढूंढना आवश्यक था, फिर श्रमिकों और फिर अमेरिकी लोगों को खोजना था।

वैसे, मुझे यहां उपयुक्त परदे के पीछे की एक सूची मिली:
www.proxz.com/proxy_list_anonymous_us_0.html

लेकिन इससे पहले, मैं सूचियों के साथ कई साइटों पर गया जिन्हें जांचने की आवश्यकता थी।
चूंकि मैं अक्सर इसे लेकर नहीं जाता हूं, इसलिए मेरे पास सही कार्यक्रम नहीं है, और वास्तविक प्रोग्रामर के लिए किसी अन्य व्यक्ति की खोज करने की तुलना में एक वास्तविक प्रोग्रामर के लिए यह अधिक सुविधाजनक और दिलचस्प है।

यह स्पष्ट है कि व्यावहारिक रूप से प्रॉक्सी की जांच कंप्यूटर और नेटवर्क को लोड नहीं करती है, लेकिन इसमें काफी समय लग सकता है, यह देखते हुए कि प्रॉक्सी काम नहीं कर सकता है या बहुत दूर हो सकता है। इसलिए, मल्टीथ्रेडिंग को जोड़ना तर्कसंगत था। उसी समय, मल्टीस्ट्रेडिंग का परीक्षण विंडोज के तहत पर्ल में किया गया था, जिसमें एक्टिवस्टेट पर्ल 5.10.1 था

स्क्रिप्ट ऑपरेशन एल्गोरिथ्म इस प्रकार है:
- प्रॉक्सी की एक सूची प्राप्त करें
- कई थ्रेड शुरू करें जो सूची से परदे के पीछे से पुनरावृत्ति करेंगे
- प्रत्येक थ्रेड गुमनामी के लिए परदे के पीछे की जाँच करता है

पर्ल में धाराएं एक प्राग्म से जुड़ी होती हैं

धागे का उपयोग करें;

विवरण: perldoc.perl.org/threads.html

यदि इसके उपयोग के दौरान आपको इस तरह का इंकार मिलता है:

इस पर्ल को कॉन्फ़िगर नहीं किया गया है और काम करने के लिए थ्रेड मॉड्यूल के लिए ठीक से बनाया गया है। ('यूथथ्रेड्स' कॉन्फ़िगरेशन विकल्प का उपयोग नहीं किया गया है।)

तो यह पर्ल के इकट्ठा करने का समय है।

उसके बाद हम कमांड के साथ एक नया धागा बना सकते हैं

$ धागा = धागे-> बनाएँ (\ & job_todo, $ param);

job_todo उस फ़ंक्शन का नाम है जिसमें स्ट्रीम के कार्य का वर्णन किया जाना चाहिए।
फ़ंक्शन का उल्लेख करने के बाद, आप अन्य मापदंडों को पारित कर सकते हैं, उदाहरण के लिए, धारा की अनुक्रम संख्या। सही है, स्ट्रीम में एक tid () विधि है, जो सीरियल नंबर लौटाती है, लेकिन एक उदाहरण के लिए हम इस पैरामीटर को छोड़ देंगे।
आउटपुट एक $ थ्रेड ऑब्जेक्ट है।

हालांकि, यदि आप इस तरह से सभी प्रवाह बनाते हैं, और कार्यक्रम में आगे कुछ नहीं करते हैं, तो मुख्य स्क्रिप्ट समाप्त हो जाएगी और सभी धागे काम पूरा किए बिना प्रेरणा पर मर जाएंगे।

थ्रेड्स के लिए प्रतीक्षा करने के लिए मुख्य प्रोग्राम के लिए, आपको कमांड चलाना होगा

$ धागा-> जुड़ना ();

धाराओं के साथ एक और मुद्दा यह है कि वे एक-दूसरे के साथ जानकारी का आदान-प्रदान कैसे कर सकते हैं, उदाहरण के लिए, यह पता लगाने के लिए कि सूची से कौन सी प्रॉक्सी पहले से ही संसाधित हो चुकी हैं और कौन सी नहीं हैं? तथ्य यह है कि, डिफ़ॉल्ट रूप से, प्रत्येक थ्रेड को बनाए जाने से पहले घोषित चर की एक स्वतंत्र प्रतिलिपि प्राप्त होती है, और वे राजकुमार से सिंड्रेला की तरह एक-दूसरे से कटे रहते हैं।

इसके लिए एक प्रज्ञा है

धागे का उपयोग करें: साझा;

जो आपको सामान्य घोषित करने और उपयोग करने की अनुमति देता है, अर्थात्। साझा, चर। यदि आप इस तरह एक चर घोषित करते हैं:

मेरी $ useme: साझा = 0;

तब सभी थ्रेड्स के लिए $ useme वैरिएबल आम हो जाएगा - जब एक थ्रेड अपना मान बदलता है, तो अन्य थ्रेड्स वह मान देखते हैं जो पहले से बदल चुका है।

इस प्रकार, हम एक समरूपता का एक सरणी बना सकते हैं, और यह उस सरणी की स्थिति के लिए एक साझा सूचक है जिस पर अगला प्रॉक्सी प्रॉक्सी निहित है।

इसलिए, काम की शुरुआत में प्रत्येक धागा सूची से अगला प्रॉक्सी लेता है, और सूचक को सरणी के माध्यम से आगे बढ़ाता है।
बस कानूनी क्षमता पर प्रोक्सा की जाँच की। जैसा कि आप जानते हैं, तीन प्रकार के परदे के पीछे हैं - अनाम, खुला और गैर-काम।
और फिर भी, अनाम बहुत गुमनाम हैं (जिसमें से यह जानने का कोई तरीका नहीं है कि इसके पीछे कौन है) और कमजोर रूप से अनाम (जो किसी एक चर में अभी भी एक गुप्त धूर्त के आईपी पते को संचारित करता है)।
हमें बस यह समझने की जरूरत है कि क्या प्रॉक्सी काम करता है, और इस प्रॉक्सी का उपयोग करते समय हमें किस तरह का आईपी मिलता है। इसके लिए, कोई भी उपयुक्त वेबसाइट जो सभी को अपना बाहरी आईपी पता बताती है।

मैंने प्रयोग के लिए साइट www.myip.ru को चुना। हालांकि, यदि आप एक निरंतर आधार पर परदे के पीछे की जाँच करने में लगे हुए हैं, तो अपनी खुद की सरल स्क्रिप्ट बनाने और इसे कुछ सर्वर पर रखना बेहतर है - दोनों तेजी से और हम एक और सर्वर लोड नहीं करेंगे।
इसके अलावा, यह स्क्रिप्ट इतनी सरल हो सकती है:

#! / usr / बिन / पर्ल

"सामग्री-प्रकार: टेक्स्ट / html \ n \ n $ ENV {REMOTE_ADDR}" प्रिंट करें ;

तो, धारा, प्रॉक्सी लेते हुए, इसके माध्यम से एक साइट का अनुरोध करने की कोशिश करता है और यह देखता है कि कौन सी साइट वापस आती है।
यदि अनुरोध पास नहीं होता है, तो प्रॉक्सी काम नहीं करता है, यदि साइट हमारे अपने आईपी को दिखाती है, तो इसका मतलब है कि प्रॉक्सी खुला है। लेकिन अगर साइट एक अलग आईपी दिखाती है, तो हम लक्ष्य तक पहुंच गए हैं, काम करने वाले और अनाम दोनों का सहारा लेते हैं।

स्क्रिप्ट एक फ़ाइल से परदे के पीछे की सूची प्राप्त करती है जिसका प्रारूप महत्वपूर्ण नहीं है, मुख्य बात यह है कि बंदरगाहों के साथ प्रॉक्सी आईपी पते हैं, 12.34.56.78:8080 फॉर्म में
बेशक, आप थोड़ा आगे जा सकते हैं और स्वचालित रूप से प्रॉक्सी की सूची प्रकाशित करने वाली किसी भी साइट को पार्स कर सकते हैं।

इसके अलावा, मुझे देश से संबंधित प्रॉक्सी की जांच करने की आवश्यकता नहीं थी, क्योंकि पहला प्रॉक्सी अमेरिका से था। यह आपके लिए आपके होमवर्क (जियो :: आईपी का उपयोग करें) के रूप में करना भी आसान होगा।

निम्नलिखित टिप्पणियों के साथ स्क्रिप्ट का पाठ है। जैसा चाहो प्रयोग करो। भयंकर लाभ की स्थिति में, मैं दान के लिए वॉलेट नंबर भेजूंगा।
इन सबसे ऊपर, किसी को कोई नुकसान न पहुंचाएं, और आपके साथ हो सकता है।

पुनश्च: वीडियो देखा - छोटा, लेकिन दिलचस्प।

#! / usr / bin / perl -w

# लाइब्रेरी कनेक्ट करें
सख्त का उपयोग करें ;
LWP का उपयोग करें :: UserAgent ;
धागे का उपयोग करें ;
धागे का उपयोग करें : साझा ;

# चर सेट करना
मेरे @ सूत्र ;
मेरे @proxy ;
मेरे $ धागे = 100 ;
मेरा $ last_p : साझा = 0 ;
मेरे $ ip_checker = 'http://www.myip.ru/get_ip.php?loc=' ;

# काम करने वाले अनाम प्रॉक्सी की सूची
ओपन लॉग , ">> प्रॉक्सी.लॉग" ;

# अपने वर्तमान बाहरी आईपी का पता लगाएं
मेरे $ ua = LWP :: UserAgent -> नया ;
$ ua -> एजेंट ( "मोज़िला / 5.0" ) ;
मेरा $ Res = $ ua -> मिलता है ( $ ip_checker ) ;
बाहर निकलें अगर ( $ Res -> is_success ) ;
मेरे $ s = $ res -> डीकोडेड / कॉन्टेंट ;
$ s = ~ m / ( \ d + \ । \ d + \ _ । \ d + \ । \ d + ) / s ;
मेरे $ myip = $ 1 ;

# परदे के पीछे की सूची पढ़ें
खुला फिल्म्स , 'प्रॉक्सी । लिस्ट' ;
जबकि ( $ s = <FIL> )
{
जबकि ( $ s = ~ s / ( \ d + \ _ । d + \ _ \ _ d + \ _ \ d +: \ d + // )
{
धक्का ( @proxy , $ 1 ) ;
}
}
प्रिंट "प्रॉक्सी पाया:" । @proxy । " \ _ " ;

# थ्रेड्स की सही मात्रा बनाएं
मेरे $ t ( 1 .. $ धागे ) के लिए {
पुश @ थ्रेड्स , थ्रेड्स -> क्रिएट ( \ & check_proxy , $ t ) ;
}
# हम सभी धागे के अंत की प्रतीक्षा कर रहे हैं
मेरे $ t ( @threads ) पर पहुंचें {
$ t -> जुड़ ( ) ;
}

उप check_proxy
# प्रॉक्सी जांच
{
# करंट नंबर
मेरी $ संख्या = पाली ;
प्रिंट "+ थ्रेड $ संख्या शुरू हुई। \ n " ;

# अनंत लूप
जबकि ( 1 )
{
# सूची में अगला नंबर लें
मेरे $ seq = $ last_p ++;
# यदि सूची समाप्त हो गई है, तो समाप्त करें
अगर ( $ seq > = @proxy )
{
प्रिंट "- थ्रेड $ संख्या में किया गया। \ n " ;
वापसी;
}
# सूची से अगला प्रॉक्सी प्राप्त करें
मेरे $ प्रॉक्सी = $ प्रॉक्सी [ $ seq ] ;

# पत्थरबाजी शुरू
मेरे $ ua = LWP :: UserAgent -> नया ;
$ ua -> एजेंट ( "मोज़िला / 5.0" ) ;
$ ua -> प्रॉक्सी ( [ 'http' ] , "http: // $ प्रॉक्सी /" ) ;
मेरा $ Res = $ ua -> मिलता है ( $ ip_checker ) ;

# रिपोर्ट
printf ( "थ्रेड% 02d; Seq।% 03d; प्रॉक्सी% 20s; स्थिति:" , $ num , $ seq , $ xy ) ;
# काम नहीं करता
अगर ( $ res -> is_success ) {
"कनेक्ट करने में असमर्थ। \ n " प्रिंट करें ;
अगला ;
}

# एक अलग पेज
मेरे $ s = $ res -> डीकोडेड / कॉन्टेंट ;

# पेज पर हमारा आईपी है, फिर प्रॉक्सी खुला है
अगर ( $ s = ~ m / $ myip / s )
{
प्रिंट करें "खोलें। \ n " ;
}
# जांच जरूरी नहीं कि वह अपना आईपी छोड़ दे।
# यदि पृष्ठ पर कुछ आईपी है, लेकिन हमारा नहीं है, तो प्रॉक्स अनाम है
elsif ( $ s = ~ m / (\ d + \ _ । d d \ _ । \ d + \ _ \ d + / / ))
{
"बेनामी! \ n " प्रिंट करें ;
प्रिंट लॉग "$ प्रॉक्सी \ n " ;
}
# कुछ बुरा हुआ
अन्यथा
{
प्रिंट "काम नहीं कर रहा ... \ n " ;
}
}
}