C++

Question

matplotlib एम्बेड मैं सी ++ कोड के साथ एक सॉकेट से संदेश पढ़ रहा हूँ और matplotlib साथ सहभागी यह साजिश कोशिश कर रहा हूँ, लेकिन यह अजगर कोड मुख्य थ्रेड, कोई फर्क नहीं पड़ता मैं show() या ion() और draw() का उपयोग को अवरुद्ध कर देगा लगता है। ion() और draw() पायथन में अवरुद्ध नहीं होंगे।

कोई विचार सी ++ कोड में matplotlib के साथ अंतःक्रियात्मक रूप से साजिश कैसे करें?

एक उदाहरण वास्तव में अच्छा होगा।

बहुत बहुत धन्यवाद।

Answer 1

आप ब्लॉकिंग फ़ंक्शन पर कॉल करने के लिए एक नया थ्रेड बनाने का भी प्रयास कर सकते हैं, ताकि यह आपके मुख्य प्रोग्राम लूप में आईओ को अवरुद्ध न करे। एक अप्रयुक्त एक खोजने के लिए थ्रेड ऑब्जेक्ट्स और लूप के सरणी का उपयोग करें, अवरुद्ध कॉल करने के लिए थ्रेड बनाएं, और एक और थ्रेड है जो पूरा होने पर उन्हें शामिल करता है।

इस कोड को एक त्वरित थप्पड़-साथ मैं प्रदर्शित करने के लिए मैं क्या मतलब है है के बारे में अवरुद्ध कार्यों के लिए छद्म अतुल्यकालिक व्यवहार पाने के लिए ... मैं इसे बहुत अच्छी तरह से संकलित या कंघी नहीं किया है इस पर धागे का उपयोग कर, यह बस है दिखाने के लिए आप इसे कैसे पूरा करें।

#include <pthread.h> 
#include <sys/types.h> 
#include <string> 
#include <memory.h> 
#include <malloc.h> 
#define MAX_THREADS 256 // Make this as low as possible! 
using namespace std; 
pthread_t PTHREAD_NULL; 
typedef string someTypeOrStruct; 
class MyClass 
{ 
    typedef struct 
    { 
     int id; 
     MyClass *obj; 
     someTypeOrStruct input; 
    } thread_data; 

    void draw(); //Undefined in this example 
    bool getInput(someTypeOrStruct *); //Undefined in this example 
    int AsyncDraw(MyClass * obj, someTypeOrStruct &input); 
    static void * Joiner(MyClass * obj); 
    static void * DoDraw(thread_data *arg); 
    pthread_t thread[MAX_THREADS], JoinThread; 
    bool threadRunning[MAX_THREADS], StopJoinThread; 

    bool exitRequested; 
public: 
    void Main(); 
}; 

bool MyClass::getInput(someTypeOrStruct *input) 
{ 
} 

void MyClass::Main() 
{ 
    exitRequested = false; 
    pthread_create(&JoinThread, NULL, (void *(*)(void *))MyClass::Joiner, this); 

    while(!exitRequested) 
    { 
     someTypeOrStruct tmpinput; 
     if(getInput(&tmpinput)) 
      AsyncDraw(this, tmpinput); 
    } 

    if(JoinThread != PTHREAD_NULL) 
    { 
     StopJoinThread = true; 
     pthread_join(JoinThread, NULL); 
    } 
} 

void *MyClass::DoDraw(thread_data *arg) 
{ 
    if(arg == NULL) return NULL; 
    thread_data *data = (thread_data *) arg; 
    data->obj->threadRunning[data->id] = true; 
    // -> Do your draw here <- // 
    free(arg); 
    data->obj->threadRunning[data->id] = false; // Let the joinThread know we are done with this handle... 
} 

int MyClass::AsyncDraw(MyClass *obj, someTypeOrStruct &input) 
{ 
    int timeout = 10; // Adjust higher to make it try harder... 
    while(timeout) 
    { 
     for(int i = 0; i < MAX_THREADS; i++) 
     { 
      if(thread[i] == PTHREAD_NULL) 
      { 
       thread_data *data = (thread_data *)malloc(sizeof(thread_data)); 
       if(data) 
       { 
        data->id = i; 
        data->obj = this; 
        data->input = input; 

        pthread_create(&(thread[i]), NULL,(void* (*)(void*))MyClass::DoDraw, (void *)&data); 
        return 1; 
       } 
       return 0; 
      } 
     } 
     timeout--; 
    } 
} 

void *MyClass::Joiner(MyClass * obj) 
{ 
    obj->StopJoinThread = false; 
    while(!obj->StopJoinThread) 
    { 
     for(int i = 0; i < MAX_THREADS; i++) 
      if(!obj->threadRunning[i] && obj->thread[i] != PTHREAD_NULL) 
      { 
       pthread_join(obj->thread[i], NULL); 
       obj->thread[i] = PTHREAD_NULL; 
      } 
    } 
} 

int main(int argc, char **argv) 
{ 
    MyClass base; 
    base.Main(); 
    return 0; 
} 

इस तरह आप ड्रॉ होने के दौरान इनपुट स्वीकार करना जारी रख सकते हैं।

~~ फिक्स्ड तो उपरोक्त कोड वास्तव में संकलित, -lpthread जोड़ना सुनिश्चित करें