Schreiben (logging) in die gleiche Datei von verschiedenen threads , die unterschiedliche Funktionen?

In C++ gibt es eine Möglichkeit, um das schreiben in die Datei thread sicher in das folgende Szenario ?

void foo_one(){
lock(mutex1);
//open file abc.txt
//write into file
//close file
unlock(mutex1);
}

void foo_two(){
lock(mutex2);
//open file abc.txt
//write into file
//close file
unlock(mutex2);
}

In meiner Anwendung (multi-threaded) , ist es wahrscheinlich, dass foo_one() und foo_two() werden ausgeführt, indem zwei verschiedene threads zur gleichen Zeit .
Gibt es eine Möglichkeit, um die oben genannten thread-safe ?

Ich habe gedacht, dass mit der Datei-sperren ( fcntl und/oder lockf ), aber nicht sicher, wie Sie Sie zu benutzen, weil fopen() ist in der Anwendung ( performance-Gründen ) , und es wurde festgestellt, dass irgendwo diese Datei Schlösser sollten nicht verwendet werden, die mit fopen ( da es gepuffert ist )

PS : Die Funktionen foo_one() und foo_two() sind in zwei verschiedenen Klassen , und es gibt keine Möglichkeit, eine gemeinsam genutzte Daten zwischen Ihnen : (und leider ist das design ist so, dass eine Funktion nicht aufrufen kann, eine andere Funktion .

Verwandte: stackoverflow.com/questions/7565034/...
Ja. Sie brauchen nur eine Sperre, stellt die Datei (nennen wir ihn mutex3). PS. Wenn Sie das schreiben von C++ - code, Sie sollten mit RAII zu sperren/entsperren die Mutexe.
Die Funktionen foo_one() und foo_two() sind in zwei verschiedenen Klassen , und es gibt keine Möglichkeit, eine gemeinsam genutzte Ressource dazwischen 🙁 , und leider ist das design ist so, dass eine Funktion nicht aufrufen kann, eine andere Funktion .
Konnte gerade noch ein "Write" - Funktion einer Klasse aufgerufen wird, auf der es einen eigenen thread. Nur Schleife, bis es zu beenden. Dann jedes mal, wenn du etwas schreiben musst, um die Datei, können Sie einfach schieben Sie es in die Vektor-und der thread Schreibe Sie auf die Datei, sobald es eintrifft.
Verwandte: stackoverflow.com/questions/439791/...

InformationsquelleAutor k0n3ru | 2012-10-15

c++file logging multithreading

8

Fügen Sie eine Funktion für die Protokollierung.

Beide Funktionen rufen Sie die logging-Funktion (die die entsprechende Verriegelung).
```
mutex  logMutex;
void log(std::string const& msg)
{
    RAIILock  lock(logMutex);

    //open("abc.txt");
    //write msg
    //close
}
```
+1. In der Realität würde man Sie sowohl Teil einer Klasse.
Wenn die Leistung ein Problem, kann die sperren nicht etwas k0n3ru möchte.
Wo die RAIILock kam-code?
Es ist eine generische Referenz auf eine Klasse, die verwendet RAII zu Sperren/Entsperren ein anderes Objekt. Sie sind einfach zu schreiben. Ein Beispiel ist std::lock_guard

InformationsquelleAutor Martin York
2

Wenn Sie wirklich brauchen ein-logger, versuchen Sie nicht, es zu tun, einfach durch das schreiben in Dateien, und vielleicht verwenden Sie einen dedizierten logger und trennt so die sorgen Weg von der code Sie schreiben. Es gibt eine Anzahl von thread-safe-Logger: das erste, das mir einfällt: g2log. Googeln weiteren finden Sie log4cplus, eine Diskussion hier, sogar ein eine minimalistische, +1

InformationsquelleAutor Dmitry Ledentsov
1

Wenn die Essenz der Funktionen foo_one() und foo_two() sind nur, die Datei zu öffnen, etwas schreiben, und schließen Sie es dann mit den gleichen mutex, um Sie zu halten aus messing gegenseitig:
```
void foo_one(){
  lock(foo_mutex);
  //open file abc.txt
  //write into file
  //close file
  unlock(foo_mutex);
}

void foo_two(){
  lock(foo_mutex);
  //open file abc.txt
  //write into file
  //close file
  unlock(foo_mutex);
}
```
Natürlich, dies setzt Voraus, diese sind die einzigen Autoren. Wenn andere threads oder Prozesse in die Datei schreiben, wird eine lock-Datei könnte eine gute Idee sein.

Leider sind Die Funktionen foo_one() und foo_two() sind in zwei verschiedenen Klassen , und es gibt keine Möglichkeit, eine gemeinsam genutzte Daten zwischen Ihnen .
Was ist mit der lock-Datei Idee, dann? Es ist eine Frage, die beschreibt die Methode hier: stackoverflow.com/questions/1599459/optimal-lock-file-method

InformationsquelleAutor wallyk
1

Sollten Sie das tun, haben eine Struktur mit einer mutex-und einer ofstream:
```
struct parser {
    ofstream myfile
    mutex lock
};
```
Dann können Sie diese Struktur (a) foo1 und foo2 als void*
```
parser * a = new parser();
```
Initialisierung des mutex-Sperre, dann übergeben Sie die Struktur, um sowohl die Funktionen.
```
void foo_one(void * a){
     parser * b = reinterperet_cast<parser *>(a);
     lock(b->lock);
         b->myfile.open("abc.txt");
         //write into file
         b->myfile.close();
      unlock(b->mutex);
}
```
Können Sie das gleiche tun für die foo_two Funktion. Dies wird ein thread-sicherer Mittel zum schreiben in die gleiche Datei.

Obwohl dieser Ansatz "funktioniert" und deine Antwort ist nett geschrieben, dies ist ein Ort, wo Sie brauchen nur zu wissen über die Verfolgung der mutex mit RAII.

InformationsquelleAutor Fantastic Mr Fox

Versuchen, diesen code. Ich habe dies mit MFC-Konsolenanwendung

#include "stdafx.h"
#include <mutex>

CWinApp theApp;
using namespace std;


const int size_ = 100; //thread array size
std::mutex mymutex;
void printRailLock(int id) {
    printf("#ID :%", id);
    lock_guard<std::mutex> lk(mymutex); //<- this is the lock
    CStdioFile lastLog;
    CString logfiledb{ "_FILE_2.txt" };
    CString str;
    str.Format(L"%d\n", id);
    bool opend = lastLog.Open(logfiledb, CFile::modeCreate | CFile::modeReadWrite | CFile::modeNoTruncate);
    if (opend) {
        lastLog.SeekToEnd();
        lastLog.WriteString(str);
        lastLog.Flush();
        lastLog.Close();
    }
}
int main()
{
    int nRetCode = 0;
    HMODULE hModule = ::GetModuleHandle(nullptr);

    if (hModule != nullptr)
    {       
        if (!AfxWinInit(hModule, nullptr, ::GetCommandLine(), 0))
        {            
            wprintf(L"Fatal Error: MFC initialization failed\n");
            nRetCode = 1;
        }
        else
        {
            std::thread threads[size_];
            for (int i = 0; i < size_; ++i) {
                threads[i] = std::thread(printRailLock, i + 1);
                Sleep(1000);
            }
            for (auto& th : threads) { th.hardware_concurrency(); th.join(); }
        }
    }
    else
    {       
        wprintf(L"Fatal Error: GetModuleHandle failed\n");
        nRetCode = 1;
    }

    return nRetCode;
}

Referenz:

InformationsquelleAutor Elshan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.