线程安全流和流操纵器

Question

我正在尝试编写一个线程安全的记录器类，以便我可以执行与 cout 完全相同的操作，但具有线程安全性。

这是记录器类（仍在处理所需的锁定类型）

class logger {

public:

    logger(LOGGER::output_type type);

    logger(const logger& orig);

    virtual ~logger();

    template <typename T>
    logger & operator << (const T & data){
        boost::mutex::scoped_lock io_mutex_lock(io_mutex);
        (*out)<<data;
        return *this;
    }

private:
    static boost::mutex io_mutex;
    std::ostream * out;

};

问题是我无法执行以下操作

1. log<<"asdfg";
   我必须这样做
   log<

2. int i = 10;
log<<字符串（“i =”）<<我<< endl;

以下是编译错误。

gcc.compile.c++ src/simpleThread/bin/gcc-4.4.5/debug/simpleThread.o
src/simpleThread/simpleThread.cc: In function ‘int main()’:
src/simpleThread/simpleThread.cc:28: error: no match for ‘operator<<’ in ‘((logger*)logOut.logger::operator<< [with T = char [18]](((const char (&)[18])"fibonacci thread ")))->logger::operator<< [with T = int](((const int&)((const int*)(& i)))) << std::endl’

所以我想我错过了 C++ 的一些重要概念。请告诉我这是什么？ 我的要求可以实现吗

谢谢 基兰

Answer 1

请注意，您的记录器类仍然不是线程安全的：

int i = 10;
log <<string ("i = ") << i << endl;

没有什么可以阻止该线程被另一个打印到记录器的线程抢占并生成类似的内容：

i = i = 12

而不是：

i = 1
i = 2

如果您有一个带有可变参数模板的编译器，这是解决此问题的一种方法：

#include <ostream>
#include <mutex>

inline void sub_print(std::ostream&) {}

template <class A0, class ...Args>
void
sub_print(std::ostream& os, const A0& a0, const Args& ...args)
{
    os << a0;
    sub_print(os, args...);
}

std::mutex&
io_mut()
{
    static std::mutex m;
    return m;
}

template <class ...Args>
void
log(std::ostream& os, const Args& ...args)
{
    std::lock_guard<std::mutex> _(io_mut());
    sub_print(os, args...);
    os.flush();
}

#include <iostream>

int main()
{
    int i = 10;
    log(std::cout, "i = ", i, '\n');
}

即互斥锁被锁定，直到处理给定日志消息的所有参数为止。 std::endl 通过在每条消息后始终刷新流来单独处理。

Answer 2

您的问题是 logger 不是流，因此通常的流运算符将不起作用，只能使用您定义的单个流运算符。

您可以通过自己定义 endl 来工作：

inline logger& endl(logger& log)
{
    // do something to *out
    return log;
}

现在 log << “你好！” << endl; 会起作用。

能够链接多个<<像流一样一起操作，您必须为记录器定义所有运算符（就像流一样）。

Answer 3

我认为你在太低的水平上引入同步。要理解原因，假设线程 1 执行：

log << "This is " << "my " << "log message" << endl;

而线程 2 执行：

log << "Hello, " << "World!" << endl;

在这种情况下，日志文件（或控制台输出）可能包含交错的消息，例如：

This is Hello, my World!
log message

为了避免此问题，您的应用程序将必须构建
将整个消息作为单个字符串，然后才将该字符串传递给记录器对象。例如：

ostringstream msg;
msg << "This is " << "my " << "log message" << endl; 
log << msg.str();

如果您采用这种方法，那么您的记录器类不需要为 endl 和多种类型重载 operator<<。

Answer 4

我通过一些简化测试了您的程序，如下所示，它编译并运行良好，这意味着问题可能出在其他地方：

#include <iostream>

class logger {

public:

//    logger(LOGGER::output_type type);

    logger(std::ostream& os): out(&os) {}

    ~logger() {}

    template <typename T>
    logger & operator << (const T & data){
//        boost::mutex::scoped_lock io_mutex_lock(io_mutex);
        (*out)<<data;
        return *this;
    }

private:
//    static boost::mutex io_mutex;
    std::ostream * out;

};

int main()
{
        logger log(std::cout);
        log << std::string("hello ");
        log << "world\n";
}

Answer 5

在深入研究 iostreams 并根据 Bo Persson 的提示后，我认为我找到了更好的解决方案，因为我不需要为每个 ios 操纵器分别编写一个函数。所以这里是

    logger& operator<<(std::ostream& (*pf)(std::ostream&)) {
        (*out)<<pf;
        return *this;
    }

iostreams 和应用程序的解释搜索。

这是完整的 boost:: 线程安全实现（可能需要一些重构和优化），使用 Ciaran-Mchale

/* 
 * File:   logger.h
 * Author: Kiran Mohan
 *
 */

#ifndef LOGGER_H
#define LOGGER_H

#include <boost/thread.hpp>
#include <iostream>

namespace LOG {

    enum output_type {
        STDOUT,
        STDERR
    };

    /**
     * a thread safe logger to print to stdout or stderr
     */
    class logger {
    public:

        logger(LOG::output_type type);

        logger(const logger& orig);

        virtual ~logger();

        template <typename T>
        logger & operator <<(T data) {
            /* Takes any data type and stores in a stringstream
             */
            (*oss) << data;
            return *this;
        }

        logger & operator<<(std::ostream& (*pf)(std::ostream&)) {
            // for stream manipulators
            (*oss) << pf;
            return *this;
        }

        logger & operator<<(logger & (*pf)(logger &)) {
            //applicator - mainly calling the print function;
            return pf(*this);
        }

        friend logger & flush(logger & l);

        logger & print() {
            boost::mutex::scoped_lock io_mutex_lock(io_mutex);
            (*out) << oss->str() << std::flush;
            delete oss;
            oss = new std::ostringstream;
            return *this;
        }

    private:

        static boost::mutex io_mutex;
        std::ostream * out;

        std::ostringstream * oss;

    };

    logger & flush(logger & l);

};
#endif  /* LOGGER_H */
/* 
 * File:   logger.cc
 * Author: aryan
 * 
 */

#include <boost/thread/pthread/mutex.hpp>
#include <iostream>
#include "logger.h"

using namespace LOG;
boost::mutex logger::io_mutex;

logger::logger(LOG::output_type type) {
    if (type == LOG::STDOUT) {
        out = &std::cout;
    } else {
        out = &std::cerr;
    }
    oss = new std::ostringstream;
}

logger::logger(const logger& orig) {
    out = orig.out;
}

logger::~logger() {
    delete oss;
}

logger & LOG::flush(logger & l) {
    l.print();
    boost::this_thread::yield();
    return l;
}

像这样使用它

LOG::logger logOut (LOG::STDOUT);
logOut<<"Hello World\n"<<LOG::flush;