Gibt es eine Möglichkeit, Atomarität sicherzustellen, während ein Multithread-Programm mit Signalhandlern zur Verfügung steht?

Question

Wenn ich ein Programm wie diese (in Pseudo-Code):

mutex_lock; 
func() { 
    lock(mutex_lock); 
    // Some code (long enough to make a 
    // race condition if no proper synchronisation 
    // is available). We also going to call a signal, 
    // say, SIGINT, through (ctrl-c), while we are in 
    // the range of locking and unlocking the lock. 
    unlock(mutex_lock); 
} 

sig_handler_func(sig) { 
    // Say, we are handling SIGINT (ctrl-c) signal 
    // And we need to call func from here too. 
    if (sig == SIGINT) { 
     func(); 
    } 
} 

main() { 
    // Calling func from main 
    func(); 
} 

dann gäbe es ein Deadlock bei dem Versuch, das Schloss in func zu erwerben, während es bereits aus dem ‚Haupt‘ Anrufer erworben wird. Ich habe mich gefragt, ob es eine Möglichkeit gibt, die Signalbehandlung in der C-Sprache zu unterbrechen, insbesondere wenn in diesem Beispiel func eingegeben und die Sperre akquiriert wird, und die Signalbehandlung wiederaufgenommen wird und die Handler beim Verlassen der Funktion aufgerufen werden.

Answer 1

Sie wollen pthread_sigmask, die Multi-Thread-Version von sigprocmask

Hier einige Beispiel-Pseudocode:

int 
main(void) 
{ 
    sigset_t omask; 
    sigset_t nmask; 

    // add as many signals as you want to the mask ... 
    sigemptyset(&nmask); 
    sigaddset(&nmask,SIGINT); 

    // [temporarily] block signals 
    pthread_sigmask(SIG_BLOCK,&nmask,&omask); 

    // call function safely 
    func(); 

    // restore signal mask 
    pthread_sigmask(SIG_SETMASK,&omask,NULL); 

    // pending signals should occur now ... 
} 

ich nicht ganz sicher bin, aber können Sie pthread_sigmask verwenden müssen Signale in alle zu blockieren aber ein Thread und tun Sie das obige nur aus diesem Thread.

Auch ich würde nachlässig sein, wenn ich nicht sage, dass ich Ihren Code umgestalten würde. Die Anzahl der Dinge, die Sie in einem Signal-Handler tun können [von dieser Seite] begrenzt ist (zB keine malloc, keine printf, etc.)

Widmen einen Thread für Signalverarbeitung und nachdem er sigsetjmp tun und die Signal-Handler tun siglongjmp .

Oder der Signal-Handler hat einen flüchtigen globalen Wert gesetzt (z. B. signal_occurred), der auf Basisebene überwacht wird.

Somit können alle "schweren Arbeiten", die Sie im Signal-Handler durchführen, von der Basis-Task-Ebene aus durchgeführt werden, wo Sie alles tun können.

Answer 2

Sie benötigen zwei Sperren. Der eine, der in Ihrem func() verwendet wird, und einer, um die Signalmaske des Prozesses zu schützen.

Sie müssen dafür Maskierung und Demaskierung das Signal Atom auch:

static pthread_mutex_t mask_mutex = PTHREAD_MUTEX_INITIALIZER; 
sigset_t old_set; 
sigset_t new_set; 

sigemptyset(&new_set); 
sigaddset(&new_set, SIGINT); 

pthread_mutex_lock(&mask_mutex); 

pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask); 

func(); 

pthread_sigmask(SIG_SETMASK, &old_mask, NULL); 

pthread_mutex_unlock(&mask_mutex); 

Ohne Sperre um die pthread_sigmask(), sind Fäden wahrscheinlich korrupt den Prozess sigmask als Ausführung überlappt.

Answer 3

Sie können die Test Mutex Funktionen (Trylock) in dieser Art von undefinierten Situationen, um sicher zu sein. Und damit müssen Sie nicht unbedingt auch blocken.