std::lock_guard 使用可变参数模板

Question

[无需点击链接即可理解问题]。

我在this answer, together with the synchronized file writing of 中结合了单例模式的实现。

然后我想看看 SynchronizedFile 的接口是否可以提供可变参数模板 write 方法，但我不知道如何将它与 std::lock_guard 正确地结合起来.

下面是一个无效的示例。在这种情况下，它不起作用，因为（我认为）两个线程设法以非同步方式将内容泵入缓冲区 i_buf，导致乱码 LOGFILE.txt。

如果我将 std::lock_guard 放在 write 的通用模板中，那么程序不会停止。

#include <iostream>
#include <mutex>
#include <sstream>
#include <fstream>
#include <string>
#include <memory>
#include <thread>

static const int N_LOOP_LENGTH{10};

// This class manages a log file and provides write method(s)
// that allow passing a variable number of parameters of different
// types to be written to the file in a line and separated by commas.
class SynchronizedFile {
public:
    static SynchronizedFile& getInstance()
    {
        static SynchronizedFile instance;
        return instance;
    }

private:
    std::ostringstream i_buf;
    std::ofstream i_fout;
    std::mutex _writerMutex;

    SynchronizedFile () {
        i_fout.open("LOGFILE.txt", std::ofstream::out);
    }

public:
    SynchronizedFile(SynchronizedFile const&) = delete;
    void operator=(SynchronizedFile const&)   = delete;

    template<typename First, typename... Rest>
    void write(First param1, Rest...param)
    {
        i_buf << param1 << ", ";
        write(param...);
    }

    void write()
    {
        std::lock_guard<std::mutex> lock(_writerMutex);
        i_fout << i_buf.str() << std::endl;
        i_buf.str("");
        i_buf.clear();
    }
};

// This is just some class that is using the SynchronizedFile class
// to write stuff to the log file.
class Writer {
public:
    Writer (SynchronizedFile& sf, const std::string& prefix) 
        : syncedFile(sf), prefix(prefix) {}

    void someFunctionThatWritesToFile () {
        syncedFile.write(prefix, "AAAAA", 4343, "BBBBB", 0.2345435, "GGGGGG");
    }
private:
    SynchronizedFile& syncedFile;
    std::string prefix;
};

void thread_method()
{
  SynchronizedFile &my_file1 = SynchronizedFile::getInstance();
  Writer writer1(my_file1, "Writer 1:");
  for (int i = 0; i < N_LOOP_LENGTH; ++ i)
    writer1.someFunctionThatWritesToFile();
}

int main()
{
  std::thread t(thread_method);

  SynchronizedFile &my_file2 = SynchronizedFile::getInstance();
  Writer writer2(my_file2, "Writer 2:");
  for (int i = 0; i < N_LOOP_LENGTH; ++i)
    writer2.someFunctionThatWritesToFile();

  t.join();
  std::cout << "Done" << std::endl;
  return 0;
}

我怎样才能成功地将这三个想法结合起来？

Answer 1

程序死锁，因为 write 在仍然持有锁的情况下递归调用自身。

要么使用 std::recursive_mutex ~~，要么在写完数据之后调用 write~~ 之前释放锁。 E: 解锁不行，我没想通...

E: 或锁定一次并推迟到另一个私有方法进行写入。

template<typename... Args>
void write(Args&&... args)
{
    std::unique_lock<std::mutex> lock(_writerMutex);
    _write(std::forward<Args>(args)...);
}

template<typename First, typename... Rest>
void _write(First&& param1, Rest&&... param) // private method
{
    i_buf << std::forward<First>(param1) << ", ";
    _write(std::forward<Rest>(param)...);
}

void _write()
{
    i_fout << i_buf.str() << std::endl;
    i_buf.clear();
}

std::lock_guard 使用可变参数模板

std::lock_guard with variadic templates

c++

thread-safety

variadic-templates