SDL_AddTimer e threading, coda timer di azzeramento

Question

Sto scrivendo un lettore multimediale basato su FFmpeg e ho un problema di progettazione. Il mio codice chiama una funzione per il rendering di fotogrammi video a intervalli irregolari utilizzando la funzione SDL SDL_AddTimer. Il mio problema è questo, se voglio eseguire la garbage collection quando un video termina (o la riproduzione viene interrotta) e un'altra parte, come posso assicurarmi di non avere più timer nella coda o nel mezzo dell'esecuzione per evitare di accedere ad un oggetto che improvvisamente è stato liberato.

Answer 1

C'è un sacco di modi diversi per risolvere il tuo problema in base alla tua specifica implementazione. idee di base Pochi possono essere:

1. Definire un valore booleano che specifica se il lettore viene eseguito (true = esecuzione, false = non)

2. prima di ogni chiamata relative al giocatore, controllare che variabile e, se è falso (il giocatore è fermo), chiudi la funzione (restituisce immediatamente)

3. Quindi, si chiama removeTimer e si imposta la variabile su falso per chiudere il lettore.

Tuttavia, poiché addTimer è una funzione che crea discussioni, non ci può essere a volte condizioni di gara (quello che si chiama "il mezzo di esecuzione"). È uno dei problemi principali quando usi i thread.

È necessario trovare e risolvere quelli utilizzando strumenti come mutex, semafori, ... La scelta di tali strumenti dipende molto dalla strategia che si desidera implementare per evitare quelle condizioni di gara.

Quindi, c'è senza soluzione generica. Se le prestazioni non sono un problema, puoi utilizzare quella semplice soluzione "one-lock". È un'implementazione di base della strategia della "sezione critica". Impedisce che alcune parti di codice (chiusura del lettore e esecuzione di chiamate critiche relative al suono) vengano eseguite simultaneamente.

#include <pthread.h> 
#include <stdbool.h> 

pthread_mutex_t mutex; 
bool isRunning; 
int timerID; 

void timerCallback(){ 
    // do some computations 

    pthread_mutex_lock(&mutex); 
    // that critical section, defined here will never 
    // (thank to the mutex) occur at the same time at 
    // the critical section in the close method 

    if(isRunning){ 
     // do critical calls 
    } 
    else{ 
     // do nothing 
    } 
    pthread_mutex_unlock(&mutex); 

    // do some other computations 
} 

void init(){ 
    pthread_mutex_init(&mutex, NULL); 
    isRunning = true; 
    startTimers(); 
} 

void close(){ 
    pthread_mutex_lock(&mutex); 

    // that critical section, defined here will never 
    // (thank to the mutex) occur at the same time at 
    // the critical section in the timerCallback method 
    SDL_RemoveTimer(timerID); 
    isRunning = false; 
    pthread_mutex_unlock(&mutex); 

    pthread_mutex_destroy(&mutex); 
} 

Naturalmente, non riesco a spiegare tutte le strategie di evitamento gara condizionata in un semplice post StackOverflow. Se è necessario migliorare le prestazioni, è necessario definire con precisione quale è il problema di concorrenza per il codice e scegliere una strategia corretta.