用于 C++ 的基于行的线程安全 std::cerr；

Question

创建我自己的 std::cerr 以便它是逐行线程安全的最简单方法是什么。

我最好寻找代码来做到这一点。

我需要的是，一个线程生成的一行输出（以std::endl终止）在以下情况下保持作为一行输出我实际上在我的控制台上看到它（并且没有与其他线程的输出混合）。

---

解决方案：std::cerr 比 cstdio 慢很多。我更喜欢在 CriticalSectionLocker 类中使用 fprintf(stderr, "The message") ，该类的构造函数获取线程安全锁，析构函数释放它。

Answer 1

如果可用， osyncstream (C++20) 可以解决此问题：

#include <syncstream> // C++20

std::osyncstream tout(std::cout);
std::osyncstream terr(std::cerr);

---

如果上述功能不可用，这里是一个嵌入式头文件，其中包含两个宏，用于线程安全写入 std::cout 和 std::cerr （它们必须共享一个互斥以避免输出交错）。这些基于两个其他答案，但我做了一些更改，以便轻松放入现有的代码库中。这适用于 C++11 及更高版本。

我在 4 核处理器上使用 4 个线程对此进行了测试，每个线程每秒向 tout 写入 25,000 行，偶尔输出到 terr，它解决了输出问题交错问题。与基于结构的解决方案不同，当放入此头文件时，我的应用程序没有明显的性能下降。我能想到的唯一缺点是，由于这依赖于宏，因此不能将它们放入命名空间中。

threadstream.h

#ifndef THREADSTREAM
#define THREADSTREAM

#include <iostream>
#include <sstream>
#include <mutex>

#define terr ThreadStream(std::cerr)
#define tout ThreadStream(std::cout)

/**
 * Thread-safe std::ostream class.
 *
 * Usage:
 *    tout << "Hello world!" << std::endl;
 *    terr << "Hello world!" << std::endl;
 */
class ThreadStream : public std::ostringstream
{
    public:
        ThreadStream(std::ostream& os) : os_(os)
        {
            // copyfmt causes odd problems with lost output
            // probably some specific flag
//            copyfmt(os);
            // copy whatever properties are relevant
            imbue(os.getloc());
            precision(os.precision());
            width(os.width());
            setf(std::ios::fixed, std::ios::floatfield);
        }

        ~ThreadStream()
        {
            std::lock_guard<std::mutex> guard(_mutex_threadstream);
            os_ << this->str();
        }

    private:
        static std::mutex _mutex_threadstream;
        std::ostream& os_;
};

std::mutex ThreadStream::_mutex_threadstream{};

#endif

---

test.cc

#include <thread>
#include <vector>
#include <iomanip>
#include "threadstream.h"

void test(const unsigned int threadNumber)
{
    tout << "Thread " << threadNumber << ": launched" << std::endl;
}

int main()
{
    std::locale mylocale(""); // get global locale
    std::cerr.imbue(mylocale); // imbue global locale
    std::ios_base::sync_with_stdio(false); // disable synch with stdio (enables input buffering)

    std::cout << std::fixed << std::setw(4) << std::setprecision(5);
    std::cerr << std::fixed << std::setw(2) << std::setprecision(2);

    std::vector<std::thread> threads;

    for (unsigned int threadNumber = 0; threadNumber < 16; threadNumber++)
    {
        std::thread t(test, threadNumber);
        threads.push_back(std::move(t));
    }

    for (std::thread& t : threads)
    {
        if (t.joinable())
        {
            t.join();
        }
    }

    terr << std::endl << "Main: " << "Test completed." << std::endl;

    return 0;
}

---

编译

g++ -g -O2 -Wall -c -o test.o test.cc
g++ -o test test.o -pthread

---

输出

./test
Thread 0: launched
Thread 4: launched
Thread 3: launched
Thread 1: launched
Thread 2: launched
Thread 6: launched
Thread 5: launched
Thread 7: launched
Thread 8: launched
Thread 9: launched
Thread 10: launched
Thread 11: launched
Thread 12: launched
Thread 13: launched
Thread 14: launched
Thread 15: launched

Main: Test completed.

Answer 2

这是我在某个时候编写的基于线程安全行的日志记录解决方案。它使用 boost mutex 来保证线程安全。它比必要的稍微复杂一些，因为您可以插入输出策略（它应该转到文件、stderr 还是其他地方？）：

logger.h：

#ifndef LOGGER_20080723_H_
#define LOGGER_20080723_H_

#include <boost/thread/mutex.hpp>
#include <iostream>
#include <cassert>
#include <sstream>
#include <ctime>
#include <ostream>

namespace logger {
    namespace detail {

        template<class Ch, class Tr, class A>
        class no_output {
        private:
            struct null_buffer {
                template<class T>
                null_buffer &operator<<(const T &) {
                    return *this;
                }
            };
        public:
            typedef null_buffer stream_buffer;

        public:
            void operator()(const stream_buffer &) {
            }
        };

        template<class Ch, class Tr, class A>
        class output_to_clog {
        public:
            typedef std::basic_ostringstream<Ch, Tr, A> stream_buffer;
        public:
            void operator()(const stream_buffer &s) {
                static boost::mutex mutex;
                boost::mutex::scoped_lock lock(mutex);
                std::clog << now() << ": " << s.str() << std::endl;
            }

        private:
            static std::string now() {
                char buf[64];
                const time_t tm = time(0);  
                strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&tm));
                return buf;
            }

        };

        template<template <class Ch, class Tr, class A> class OutputPolicy, class Ch = char, class Tr = std::char_traits<Ch>, class A = std::allocator<Ch> >
        class logger {
            typedef OutputPolicy<Ch, Tr, A> output_policy;
        public:
            ~logger() {
                output_policy()(m_SS);
            }
        public:
            template<class T>
            logger &operator<<(const T &x) {
                m_SS << x;
                return *this;
            }
        private:
            typename output_policy::stream_buffer m_SS;
        };
    }

    class log : public detail::logger<detail::output_to_clog> {
    };
}

#endif

用法如下所示：

logger::log() << "this is a test" << 1234 << "testing";

注意缺少 '\n ' 和 std::endl 因为它是隐式的。内容被缓冲，然后使用模板指定的策略自动输出。此实现还在该行前面添加了时间戳，因为它用于记录目的。 no_output 策略是严格可选的，当我想禁用日志记录时我会使用它。

Answer 3

这：

#define myerr(e) {CiriticalSectionLocker crit; std::cerr << e << std::endl;}

适用于大多数编译器，适用于常见情况 myerr("ERR: " << message << number)。

Answer 4

为什么不直接创建一个锁定类并在您想要执行线程安全 IO 的任何地方使用它呢？

class LockIO
{
    static pthread_mutex_t *mutex;  
public:
    LockIO() { pthread_mutex_lock( mutex ); }
    ~LockIO() { pthread_mutex_unlock( mutex ); }
};

static pthread_mutex_t* getMutex()
{
    pthread_mutex_t *mutex = new pthread_mutex_t;
    pthread_mutex_init( mutex, NULL );
    return mutex;
}
pthread_mutex_t* LockIO::mutex = getMutex();

然后你将任何你想要的 IO 放入一个块中：

std::cout <<"X is " <<x <<std::endl;

变成：

{
    LockIO lock;
    std::cout <<"X is " <<x <<std::endl;
}

Answer 5

对 unixman 评论中的方法的改进（这并不真正适合评论）。

#define LOCKED_ERR \
    if(ErrCriticalSectionLocker crit = ErrCriticalSectionLocker()); \
    else std::cerr

就可以使用它

LOCKED_ERR << "ERR: " << message << endl;

如果仔细实现 ErrCriticalSectionLocker，

。但是，我个人更喜欢肯的建议。