बंदूकधारक श्रमिकों के बीच एक ताला साझा करना

Question

क्या बंदूक कर्मियों के बीच एक मल्टीप्रोसेसिंग लॉक साझा करने का कोई अच्छा तरीका है? मैं फ्लास्क के साथ एक जेसन एपीआई लिखने की कोशिश कर रहा हूं। कुछ एपीआई कॉल एक पायथन कक्षा से बातचीत करेंगे जो एक चल रही प्रक्रिया का प्रबंधन करेगी (जैसे वीडियो रूपांतरण के लिए ffmpeg)। जब मैं अपने वेब श्रमिकों की संख्या 1 से अधिक तक बढ़ाता हूं, तो मैं कैसे सुनिश्चित कर सकता हूं कि एक ही समय में केवल 1 कर्मचारी वर्ग के साथ बातचीत कर रहा है?

मेरा प्रारंभिक विचार मल्टीप्रोसेसिंग का उपयोग करना था। लॉक ताकि स्टार्ट() फ़ंक्शन परमाणु हो। मुझे नहीं लगता कि मैं समझ गए होंगे सही जगह एक ताला ताकि एक सभी कर्मचारियों में साझा किया जाने बनाने के लिए:

# runserver.py 
from flask import Flask 
from werkzeug.contrib.fixers import ProxyFix 
import dummy 

app = Flask(__name__) 

@app.route('/') 
def hello(): 
    dummy.start() 
    return "ffmpeg started" 

app.wsgi_app = ProxyFix(app.wsgi_app) 

if __name__ == '__main__': 
    app.run() 

यहाँ है मेरी डमी आपरेशन:

# dummy.py 
from multiprocessing import Lock 
import time 

lock = Lock() 

def start(): 
    lock.acquire() 

    # TODO do work 
    for i in range(0,10): 
     print "did work %s" % i 
     time.sleep(1) 

    lock.release() 

जब मैं ताज़ा पृष्ठ कुछ बार, मैं एक साथ बुने गए प्रत्येक कॉल से आउटपुट देखता हूं।

क्या मैं यहां गलत पेड़ को भड़क रहा हूं? क्या यह सुनिश्चित करने का कोई आसान तरीका है कि केवल प्रसंस्करण कक्षा की प्रतिलिपि (यहां केवल डमी स्टार्ट() विधि) एक ही समय में चलती है? मुझे लगता है कि मुझे काम चलाने के लिए अजवाइन की तरह कुछ चाहिए (और केवल 1 कार्यकर्ता का उपयोग करें) लेकिन यह मेरी छोटी परियोजना के लिए थोड़ा अधिक लगता है।

Answer 1

मैंने कुछ करने की कोशिश की, और ऐसा लगता है। मैंने preload_app = True को अपने gunicorn.conf में रखा है और अब लॉक साझा किया जा रहा है। मैं अभी भी ठीक से देख रहा हूं कि यहां क्या हो रहा है लेकिन अभी के लिए यह काफी अच्छा है, वाईएमएमवी।

Answer 2

पीटरवे के उत्तर का पालन करें, कर्मचारी लॉक संसाधन साझा कर सकते हैं।

लेकिन, लॉक हमेशा जारी होने के लिए try-finally ब्लॉक का उपयोग करना बेहतर है।

# dummy.py 
from multiprocessing import Lock 
import time 

lock = Lock() 

def start(): 
    lock.acquire() 

    try: 
     # TODO do work 
     for i in range(0,10): 
      print "did work %s" % i 
      time.sleep(1) 
    finally: 
     lock.release()