लिनक्स पर एक कमांड कतार से समानांतर प्रसंस्करण (बैश, पायथन, रूबी ... जो कुछ भी)

Question

मेरे पास 200 कमांड की एक सूची/कतार है जिसे मुझे लिनक्स सर्वर पर खोल में चलाने की आवश्यकता है।

मैं केवल एक बार में अधिकतम 10 प्रक्रियाओं (कतार से) चलाना चाहता हूं। कुछ प्रक्रियाओं को पूरा करने में कुछ सेकंड लगेंगे, अन्य प्रक्रियाओं में अधिक समय लगेगा।

जब कोई प्रक्रिया समाप्त होती है तो मैं चाहता हूं कि अगला आदेश कतार से "पॉप" हो और निष्पादित हो।

क्या किसी को भी इस समस्या को हल करने के लिए कोड है?

आगे विस्तार:

वहाँ काम के 200 टुकड़े, किया जाना किसी प्रकार की एक कतार में जरूरत है कि है। मैं एक ही समय में काम के लगभग 10 टुकड़े चलाना चाहता हूं। जब एक धागा काम के टुकड़े को खत्म करता है तो उसे कतार के अगले भाग के लिए पूछना चाहिए। यदि कतार में कोई और काम नहीं है, तो धागा मरना चाहिए। जब सभी धागे मर गए हैं तो इसका मतलब है कि सभी काम किए गए हैं।

वास्तविक समस्या जिसे मैं हल करने का प्रयास कर रहा हूं imapsync का उपयोग पुराने मेल सर्वर से एक नए मेल सर्वर से 200 मेलबॉक्स सिंक्रनाइज़ करने के लिए कर रहा है। कुछ उपयोगकर्ताओं के पास बड़े मेलबॉक्स होते हैं और सिंक करने में लंबा समय लगता है, दूसरों के पास बहुत छोटे मेलबॉक्स होते हैं और जल्दी सिंक होते हैं।

Answer 1

मुझे लगता है कि आप इसे बनाने और मेक-जे xx कमांड का उपयोग करके ऐसा कर सकते हैं।

शायद यह

all : usera userb userc.... 

usera: 
     imapsync usera 
userb: 
     imapsync userb 
.... 

मेकअप -j 10 -f makefile की तरह एक makefile

Answer 2

यदि आप पायथन का उपयोग करने जा रहे हैं, तो मैं इसके लिए Twisted का उपयोग करने की सलाह देता हूं।

विशेष रूप से Twisted Runner।

Answer 3

क्या आप द्वारा समांतर में अपना मतलब बता सकते हैं? ऐसा लगता है कि आपको कतार में किसी प्रकार की लॉकिंग को लागू करने की आवश्यकता है, इसलिए आपकी प्रविष्टियों को दो बार नहीं चुना जाता है, और कमांड केवल एक बार चलते हैं।

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

यदि आप कुछ और विवरण प्रदान करते हैं, तो मुझे यकीन है कि हम आपकी मदद कर सकते हैं।

Answer 4

जीएनयू बनाने (और शायद अन्य कार्यान्वयन) में -j तर्क है, जो यह नियंत्रित करता है कि यह कितनी नौकरियों में एक बार चलेंगे। जब कोई काम पूरा हो जाता है, तो एक और शुरू कर देगा।

Answer 5

ठीक है, अगर वे एक दूसरे के काफी हद तक स्वतंत्र हैं, मैं करने के मामले में लगता है कि:

Initialize an array of jobs pending (queue, ...) - 200 entries 
Initialize an array of jobs running - empty 

while (jobs still pending and queue of jobs running still has space) 
    take a job off the pending queue 
    launch it in background 
    if (queue of jobs running is full) 
     wait for a job to finish 
     remove from jobs running queue 
while (queue of jobs is not empty) 
    wait for job to finish 
    remove from jobs running queue 

नोट मुख्य पाश में पूंछ परीक्षण का मतलब है कि 'चल नौकरियों कतार' अगर जगह है जब जबकि लूप पुनरावृत्त होता है - लूप की समय-समय पर समाप्त होने से रोकता है। मुझे लगता है कि तर्क ध्वनि है।

मैं देख सकता हूं कि सी में इसे आसानी से कैसे करना है - यह पर्ल में इतना कठिन नहीं होगा, और इसलिए अन्य स्क्रिप्टिंग भाषाओं - पायथन, रूबी, टीसीएल, आदि में बहुत मुश्किल नहीं है)। मुझे पूरा यकीन नहीं है कि मैं इसे खोल में करना चाहता हूं - wait शेल में कमांड सभी बच्चों को समाप्त करने के बजाए, सभी बच्चों को समाप्त करने की प्रतीक्षा करता है।

Answer 6

खोल पर, xargs समानांतर कमांड प्रोसेसिंग कतार में उपयोग किया जा सकता है।उदाहरण के लिए, समानांतर में हमेशा 3 सोता होने, 1 सेकंड प्रत्येक के लिए सो, और कुल में 10 सोता क्रियान्वित करने के लिए

echo {1..10} | xargs -d ' ' -n1 -P3 sh -c 'sleep 1s' _ 

करना और यह कुल 4 सेकंड के लिए सोने के हैं। आप नामों की एक सूची है, और मार डाला, फिर समानांतर में 3 आदेशों को क्रियान्वित करने आदेशों का नाम पास करना चाहते हैं, करते हैं

cat names | xargs -n1 -P3 process_name 

आदेश process_name alice, process_name bob और इतने पर अमल करेंगे।

Answer 7

अजगर में, आप की कोशिश कर सकते:

import Queue, os, threading 

# synchronised queue 
queue = Queue.Queue(0) # 0 means no maximum size 

# do stuff to initialise queue with strings 
# representing os commands 
queue.put('sleep 10') 
queue.put('echo Sleeping..') 
# etc 
# or use python to generate commands, e.g. 
# for username in ['joe', 'bob', 'fred']: 
# queue.put('imapsync %s' % username) 

def go(): 
    while True: 
    try: 
     # False here means no blocking: raise exception if queue empty 
     command = queue.get(False) 
     # Run command. python also has subprocess module which is more 
     # featureful but I am not very familiar with it. 
     # os.system is easy :-) 
     os.system(command) 
    except Queue.Empty: 
     return 

for i in range(10): # change this to run more/fewer threads 
    threading.Thread(target=go).start() 

untested है ...

(बेशक, अजगर स्वयं एकल धागा है। आपको अभी भी वा के संदर्भ में कई धागे का लाभ मिलना चाहिए आईओ के लिए इटिंग, हालांकि।)

Answer 8

पायथन का multiprocessing module आपकी समस्या को अच्छी तरह फिट करने लगते हैं। यह एक उच्च स्तरीय पैकेज है जो प्रक्रिया द्वारा थ्रेडिंग का समर्थन करता है।

Answer 9

इस तरह की नौकरी के लिए पीपीएसएस लिखा गया है: समांतर प्रसंस्करण खोल स्क्रिप्ट। इस नाम के लिए Google और आपको यह मिल जाएगा, मैं लिंक नहीं करूँगा।

Answer 10

Parallel इस उद्देश्य के लिए exatcly बनाया गया है।

cat userlist | parallel imapsync 

अन्य समाधान की तुलना Parallel की सुंदरता की है कि यह सुनिश्चित करें कि उत्पादन नहीं मिलाया जाता है बनाता है। Parallel में traceroute कर उदाहरण के लिए ठीक काम करता है:

(echo foss.org.my; echo www.debian.org; echo www.freenetproject.org) | parallel traceroute 

Answer 11

https://savannah.gnu.org/projects/parallel (जीएनयू समानांतर) और pssh मदद कर सकता है।

Answer 12

/tmp में लॉक फ़ाइलों का उपयोग करके 4 से अधिक सबशेल्स में नौकरियों को समानांतर करने के लिए zsh में सरल कार्य।

• #q:

  केवल गैर तुच्छ हिस्सा पहले टेस्ट में ग्लोब झंडे हैं एक परीक्षण

• [4] में ग्लोबिंग फ़ाइल नाम सक्षम: 4 परिणाम केवल
• N रिटर्न: पर त्रुटि को अनदेखा खाली परिणाम

इसे पॉज़िक्स में परिवर्तित करना आसान होना चाहिए, हालांकि यह थोड़ा और वर्बोज होगा।

\" के साथ नौकरियों में किसी भी उद्धरण से बचने के लिए मत भूलना।

#!/bin/zsh 

setopt extendedglob 

para() { 
    lock=/tmp/para_$$_$((paracnt++)) 
    # sleep as long as the 4th lock file exists 
    until [[ -z /tmp/para_$$_*(#q[4]N) ]] { sleep 0.1 } 
    # Launch the job in a subshell 
    (touch $lock ; eval $* ; rm $lock) & 
    # Wait for subshell start and lock creation 
    until [[ -f $lock ]] { sleep 0.001 } 
} 

para "print A0; sleep 1; print Z0" 
para "print A1; sleep 2; print Z1" 
para "print A2; sleep 3; print Z2" 
para "print A3; sleep 4; print Z3" 
para "print A4; sleep 3; print Z4" 
para "print A5; sleep 2; print Z5" 

# wait for all subshells to terminate 
wait