pthread_cancel बांह और पीपीसी पर अलग-अलग व्यवहार करता है?

Question

मैं वर्तमान में एक बहु-थ्रेडेड एप्लिकेशन पर काम कर रहा हूं जो हाथ और पीपीसी आर्किटेक्चर पर तैनात किया जाएगा। मुझे हाथ पर pthread_cancel के साथ कुछ समस्या है।

हाथ पर pthread_cancel पीपीसी के साथ व्यवहार नहीं करता है। थ्रेड रद्द हो जाता है लेकिन थ्रेड के स्थानीय चर के लिए विनाशक को हाथ पर नहीं बुलाया जा रहा है। मैंने pthread_cleanup_push के माध्यम से स्थापित रद्दीकरण क्लीनअप हैंडलर रूटीन को स्पष्ट रूप से परिभाषित करने का भी प्रयास किया। लेकिन धागा रद्द होने पर इसे नहीं कहा जा रहा है।

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

क्या मुझे कुछ याद आ रही है? शायद कुछ कंपाइलर विकल्प?

• प्रोग्रामिंग भाषा: सी ++
• संकलनकर्ता: हाथ-linux-जी ++/PowerPC-linux-जी ++
• ओएस: लिनक्स

संपादित करें:

मैं एक तरह से मिल गया है इस समस्या को libc bug पर लॉग ऑन किया गया।

जी ++ के बजाय जीसीसी का उपयोग करना और जोड़ने -फनो-अपवाद कंपाइलर विकल्प ने चाल की। लेकिन मैं वास्तव में इस मुद्दे के पीछे सामान समझना चाहता हूं। इसके अलावा, -फनो-अपवाद का अर्थ है कि मैं अपने आवेदन में अपवाद हैंडलिंग करने में सक्षम नहीं हूं, न कि मैं अब इसका उपयोग कर रहा हूं लेकिन मैं भविष्य में हो सकता हूं।

धन्यवाद।

Answer 1

आवेदन से सहायता के बिना थ्रेड रद्दीकरण एक बुरा विचार है। बस google। थ्रेड द्वारा आवधिक रूप से चेक किए जाने वाले फ्लैग वेरिएबल को सेट करके थ्रेड को स्वयं समाप्त करने के लिए यह बेहतर होता है।

वास्तव में रद्दीकरण इतना कठिन है कि इसे नवीनतम सी ++ 0x ड्राफ्ट से छोड़ा गया है। आप http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2497.html खोज सकते हैं और उन्हें रद्दीकरण का कोई भी उल्लेख नहीं मिलेगा। यहाँ प्रस्तावित धागा वर्ग की परिभाषा है (आप को रद्द मिलेगा नहीं):

class thread 
{ 
public: 
    // types: 
    class id; 
    typedef implementation-defined native_handle_type; // See [thread.native] 

    // construct/copy/destroy: 
    thread(); 
    template <class F> explicit thread(F f); 
    template <class F, class ...Args> thread(F&& f, Args&&... args); 
    ~thread(); 
    thread(const thread&) = delete; 
    thread(thread&&); 
    thread& operator=(const thread&) = delete; 
    thread& operator=(thread&&); 

    // members: 
    void swap(thread&&); 
    bool joinable() const; 
    void join(); 
    void detach(); 
    id get_id() const; 
    native_handle_type native_handle(); // See [thread.native] 

    // static members: 
    static unsigned hardware_concurrency(); 
};