Journalisation Threadsafe

Question

Je souhaite implémenter une classe simple pour la journalisation à partir de plusieurs threads. L'idée est que chaque objet qui veut enregistrer des données reçoit un objet ostream auquel il peut écrire des messages en utilisant les opérateurs habituels. Le comportement souhaité est, que les messages sont ajoutés au journal lorsque le flux est vidé. De cette façon, les messages ne seront pas interrompus par les messages d'autres threads. Je veux éviter d'utiliser une chaîne de caractères temporaire pour stocker le message, car cela ferait au moins la plupart des messages twoliners. Comme je le vois, la façon standard d'y parvenir serait de mettre en place mon propre destroyer, mais cela semble très lourd et sujet aux erreurs. Existe-t-il un moyen plus simple de faire cela? Si non, connaissez-vous un bon article/guide/guide sur les streambufs personnalisés?

Merci à l'avance,

Space_C0wbo0y

MISE À JOUR:

Comme il semble fonctionner, j'ai ajouté ma propre réponse.

Answer 1

Alors, je pris un coup d'œil à Boost.IOstreams et voici ce que je suis venu avec:

class TestSink : public boost::iostreams::sink { 
public: 
    std::streamsize write(const char * s, std::streamsize n) { 
     std::string message(s, n); 
      /* This would add a message to the log instead of cout. 
       The log implementation is threadsafe. */ 
     std::cout << message << std::endl; 
     return n; 
    } 
}; 

TestSink peut être utilisé pour créer un flux tampon (voir stream_buffer-template). Chaque thread recevra sa propre instance de TestSink, mais tous les TestSinks écriront dans le même journal. TestSink est utilisé comme suit:

TestSink sink; 
boost::iostreams::stream_buffer<TestSink> testbuf(sink, 50000); 
std::ostream out(&testbuf); 

for (int i = 0; i < 10000; i++) 
    out << "test" << i; 

out << std::endl; 

Le fait important est ici, que TestSink.write n'est appelée lorsque le flux est rincé (std::endl ou std::flush), ou lorsque la mémoire tampon interne de l'instance stream_buffer est pleine (le tampon par défaut la taille ne peut pas contenir 40000 caractères, donc je l'initalise à 50000). Dans ce programme, TestSink.write est appelé exactement une fois (la sortie est trop longue pour être affichée ici). De cette façon, je peux écrire un message en utilisant des flux-IO formatés normaux sans variables temporaires et être sûr que le message est enregistré dans le journal en une seule fois lorsque je vide le flux.

Je vais laisser la question ouverte un autre jour, au cas où il y aurait différentes suggestions/problèmes que je n'ai pas pris en compte.

Answer 2

Jetez un oeil à log4cpp; ils ont un support multi-thread. Cela peut vous faire gagner du temps.

Answer 3

Re. votre propre réponse. Si vous utilisez cette fonction pour la journalisation des erreurs et que vous programmez des plantages avant de vider votre flux, la journalisation est un peu inutile, n'est-ce pas?

Answer 4

Vous pensez que log4cpp est trop lourd et que vous utilisez plutôt Boost.IOStreams? Huh? Vous pouvez envisager logog. Il est compatible avec les threads pour POSIX, Win32 et Win64.