एंड्रॉइड एप्लिकेशन के लिए कस्टम लॉगिंग

Question

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

यहाँ रखने के लिए मैं

Queue<LogEntry> logQueue = new LinkedBlockingQueue<LogEntry>(); 
LogWritterThread logWritterThread = new LogWritterThread(); 

// to queue the log messages 
public void QueueLogEntry(String message) 
{ 
    LogEntry le = new LogEntry(message); 
    { 
     logQueue.add(le); 
     logQueue.notifyAll(); 
    } 

logWritterThread.start(); 
} 

    class LogWritterThread extends Thread 
{ 
    public void run() 
    { 
     try 
     { 
      while(true) 
      { 
       //thread waits until there are any logs to write in the queue 
       if(logQueue.peek() == null) 
        synchronized(logQueue){ 
         logQueue.wait(); 
        } 
       if(logQueue.peek() != null) 
       { 
        LogEntry logEntry; 
        synchronized(logQueue){ 
         logEntry = logQueue.poll(); 
        } 

        // write the message to file 
       } 
       if(Thread.interrupted()) 
        break; 
      } 
     } 
     catch (InterruptedException e) 
     {     
     } 
    } 
} 

कोई बात इस के साथ गलत है कि कोड है कोड? या एक बेहतर तरीका एक प्रवेश कतार बनाने के लिए

धन्यवाद, अनुज

Answer 1

जावा BlockingQueue कार्यान्वयन पहले से ही तुल्यकालन चिंताओं में निर्माण किया है प्रतीक्षा के आपके उपयोग, सूचित करेंगे, और सिंक्रनाइज़ निरर्थक और नहीं n है। eeded।

निर्माता/उपभोक्ता उदाहरण में मदद के लिए BlockingQueue javadoc

class LogEntry { 
    private final String message; 

    LogEntry(String msg) { 
    message = msg; 
    } 
} 

class LogProducer { 
    private final BlockingQueue<LogEntry> queue; 

    LogProducer(BlockingQueue<LogEntry> q) { 
    queue = q; 
    } 

    public void log(String msg) { 
     queue.put(new LogEntry(msg)); 
    } 
} 

class LogConsumer implements Runnable { 
    private final BlockingQueue<LogEntry> queue; 

    LogConsumer(BlockingQueue<LogEntry> q) { 
    queue = q; 
    } 

    public void run() { 
    try { 
     while(true) { 
     LogEntry entry = queue.take(); 
     // do something with entry 
     } 
    } catch(InterruptedException ex) { 
     // handle 
    } 
    } 
} 

class Setup { 
    public static void main(String[] args) { 
    BlockingQueue<LogEntry> queue = new LinkedBlockingQueue<LogEntry>(); 
    LogConsumer c = new LogConsumer(queue); 
    new Thread(c).start(); 

    LogProducer p = new LogProducer(queue); 
    p.log("asynch"); 
    p.log("logging"); 
    } 
} 

Answer 2

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

गूगल के प्रलेखन: http://saigeethamn.blogspot.com/2010/04/threads-and-handlers-android-developer.html

यह एक बेहतर उदाहरण है क्योंकि वे "msg.what" का उपयोग क्या करना है (जो आप की आवश्यकता होगी तय करने के लिए: http://developer.android.com/reference/android/os/Handler.html

यह एक बहुत ही सरल उदाहरण है प्रवेश के विभिन्न स्तरों) के लिए: https://idlesun.wordpress.com/2010/12/12/android-handler-and-message-tutorial/