event पर posponing के लिए इष्टतम विधि?

Question

मेरे छोटे ऐप में, मुझे सिस्टम से (I द्वारा नियंत्रित नहीं) पर queued onEventXXX() की एक श्रृंखला प्राप्त होती है।

EVEXXX() पर उन लोगों का समय गारंटी नहीं है। गारंटी की एकमात्र चीज यह है कि उन्हें आदेश में प्राप्त किया गया है जिसमें उन्हें कतार में रखा गया था।

अंदरूनी एक्सएक्सएक्सएक्स() मुझे एक ऑपरेशन (ओ) को आग लगाना है कि एक और प्रक्रिया (पी) चल रहा है, जबकि शुरू नहीं हो सकता है।

लेकिन मैं इसे "एक ऑपरेशन फायरिंग (ओ)" को त्याग नहीं सकता हूं। मुझे तब तक इंतजार करना चाहिए जब तक कि प्रक्रिया पूरी नहीं हो जाती, तब इसे आग लगाना।

आईओओ, मुझे उस प्रक्रिया (पी) पूरा होने तक कतार या कम से कम "ऑपरेशन फायरिंग" स्थगित करना होगा।

इस लागू करने के लिए मेरे तुरन्त पता था कि, बजाय आपरेशन (ओ) फायरिंग की, मैं करूंगा:

1. प्रारंभ एक शॉट टाइमर कि समय-समय पर प्रक्रिया पर जाँच करेगा (पी)
2. जब टाइमर elapses, अगर प्रक्रिया (पी) पूरा नहीं हुआ है, तो समय (खुद) फिर से शुरू करें।
3. जब टाइमर समाप्त हो जाता है, यदि प्रक्रिया (पी) पूर्ण हो जाती है, तो आग ऑपरेशन (ओ)।

लेकिन एंड्रॉइड की समृद्धि को जानना, मुझे संदेह है कि ऐसा करने का एक बेहतर तरीका है, जो पहले ही सिस्टम/एपीआई में बनाया गया है।

यदि उपरोक्त को लागू करने का एक बेहतर तरीका है, तो यह क्या होगा?

Answer 1

CountDownLatch सबसे अच्छा समाधान होगा बनाने की जरूरत नहीं है।

मेरे पास विस्तृत उदाहरण नहीं है, लेकिन मुझे लगता है कि आप इसे आसानी से उपयोग कर सकते हैं।

प्रक्रिया की तरह नीचे

1. CountDownLatch varaiable
2. सेट कुंडी गिनती 1
3. जब घटना हे प्राप्त करने के लिए कड़ी नामित परिभाषित करते हैं, एक नया ThreadO बनाते हैं। थ्रेडो में, प्रतीक्षा करें जब तक कि लच की गणना 0.
4. प्रक्रिया पी पूर्ण होने पर, उलटी गिनती लच तक पहुंच जाती है।

यदि आप इस तरह कोड करते हैं, तो आप आसानी से कई स्थितियों को संभाल सकते हैं।

1. यदि ओ पहले प्राप्त हुआ, तो आप पी पूरा होने तक प्रतीक्षा कर सकते हैं।
2. यदि पी पहले प्राप्त हुआ, तो आप तुरंत ओ शुरू कर सकते हैं।
3. आप टाइमआउट सुविधा का उपयोग कर सकते हैं जो CountDownLatch प्रदान करता है।

मैं एएसईसी यूनिट परीक्षण में काउंटरडाउनलैच का उपयोग करता हूं। आप यहां मेरा कोड देख सकते हैं: http://kingori.egloos.com/4554640

हालांकि यह आपके मामले की तरह नहीं है, लेकिन आप मेरे कोड से संकेत प्राप्त कर सकते हैं। इसके अलावा, CountDownLatch का जावडोक अच्छा उदाहरण प्रदान करता है।

Answer 2

मैं इसे इस तरह से करना होगा:

• onEventX में

  , अगर प्रक्रिया से बाहर निकल गया चेक, अगर हां, अपनी कार्रवाई तुरंत करने के (आप इस चरण को छोड़ सकते हैं और सिर्फ 2 कदम करते हैं)

• अन्यथा, AsyncTask जहां doInBackground में Process.waitfor() फोन बनाने के लिए, इसके पूर्ण होने पर, इस दृष्टिकोण के साथ onPostExecute

में अपनी कार्रवाई करते हैं, आप यूआई टी पर कार्रवाई फोन हड़ताल, और जितनी जल्दी हो सके।

इस कार्य के लिए टाइमर का उपयोग न करें। टाइमर एक "मतदान" विधि है। यदि आपका टाइमर बहुत तेज टिकेगा, तो आप बस CPU समय बर्बाद कर देंगे। यदि यह बहुत धीमी गति से टिक रहा है, तो आपकी कार्रवाई को संभावित देरी के साथ बुलाया जाएगा।

Answer 3

सबसे पहले, मैं सुझाव दूंगा कि यदि कोई उपयोगकर्ता किसी चीज़ पर क्लिक करता है तो उसे तत्काल परिणाम देखना चाहिए, अगर आपके मामले में बटन कार्रवाई को किसी चीज की प्रतीक्षा करने की आवश्यकता है तो उपयोगकर्ता को सिग्नल करने के लिए तुरंत बटन पर सर्कल लोडिंग एनीमेशन जोड़ें कार्रवाई जल्द ही होगी।

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

यदि प्रतीक्षा का उपयोग करें और प्रक्रिया को समाप्त करने के लिए बटन कोड प्रतीक्षा करने के लिए सूचित करने के लिए एक अन्य संभावित विकल्प, यह आम तौर पर जावा में एक बहुत ही उच्च प्रदर्शन समाधान माना जाता है:

उदाहरण के लिए

(लिखने की त्रुटियों पर ध्यान न दें, इस पर है -इस मौके):

button.setOnClickListener(new OnClickListener() { 
    public void onClick(View v) { 
     v.post(new Runnable() { 
      @Override 
      public void run() { 
       synchronized (lockObject) { 
        try { 
         lockObject.wait(); 
         doAction(); 
        } catch (InterruptedException e) {} 
       } 
      } 
     } 
    } 
} 

फिर लंबी प्रक्रिया notify है जब यह खत्म।

ध्यान दें कि new Runnable() एक नया सूत्र नहीं बनाया है, यह बस View की धागा कतार

चूहों द्वारा सुझाव दिया गया है करने के लिए एक Runnable कहते हैं, बटन onClick हैंडलर यदि प्रक्रिया वर्तमान में नहीं चल रहा है की जाँच करनी चाहिए, और यदि ऐसा है तो तुरंत कार्रवाई करें।

इस तरह आप एक नया धागा (या एक AsyncTask जो वास्तव में धागे का एक पूल है)