Qual è il modo migliore per uscire da un programma Haskell?

Question

Ho un programma che utilizza diversi thread. A quanto ho capito, quando il thread 0 termina, l'intero programma si chiude, indipendentemente da altri thread che potrebbero ancora essere in esecuzione.

Il problema è che questi altri thread potrebbero avere file aperti. Naturalmente, questo è incluso nel codice di gestione delle eccezioni che chiude in modo pulito i file in caso di problemi. Ciò significa anche che se utilizzo killThread (che è implementato tramite throwTo), il file dovrebbe anche essere chiuso prima che il thread esca.

La mia domanda è, se ho appena lasciato che il thread 0 esca, senza tentare di fermare gli altri thread, tutti i vari handle di file saranno chiusi bene? L'output bufferizzato viene scaricato?

In breve, posso uscire o devo prima eliminare manualmente i thread?

Answer 1

Dal mio test, ho scoperto un paio di cose:

1. exitFailure e amici funzionare solo in discussione 0. (La documentazione dice in realtà così, se si va alla briga di leggerlo Queste funzioni. basta gettare eccezioni, che sono silenziosamente ignorati in altri thread.)

2. Se un'eccezione uccide il tuo thread, o intero il vostro programma, eventuali handle aperti sono non arrossato. Questo è terribilmente fastidioso quando stai cercando disperatamente di capire esattamente dove si è verificato il crash del tuo programma!

così sembra, se si desidera che la roba lavata prima che il programma si chiude, quindi si devi implementare questa. Lasciare che il thread 0 muoia non svuota la roba, non genera eccezioni, termina silenziosamente tutti i thread senza eseguire gestori di eccezioni.

Answer 2

È possibile utilizzare Control.Concurrent.MVar per ottenere ciò. Un MVar è essenzialmente un flag che è "vuoto" o "pieno". Un thread può provare a leggere un MVar e se è vuoto blocca il thread. Ovunque tu abbia un thread che esegue il file IO, crea un MVar per esso e passalo come argomento a MVar. Mettere tutte le MVar s si crea in una lista:

main = do 
    let mvars = sequence (replicate num_of_child_threads newEmptyMVar) 
    returnVals <- sequence (zipWith (\m f -> f m) 
            mvars 
            (list_of_child_threads :: [MVar -> IO a])) 

Una volta che un thread figlio ha terminato tutte le operazioni sui file che si sono preoccupati, scrivere al MVar. Invece di scrivere killThread si può fare

mapM_ takeMVar mvars >> killThread 

e dove mai il tuo thread dovrebbe uscire in caso contrario, basta prendere tutte le MVar s.

Vedere documentation on GHC concurrency per ulteriori dettagli.