Почему нет потокобезопасной альтернативы С++ 11 для std::localtime и std::gmtime?

Согласно N2661, статья, в которой добавлено <chrono>:

Эта статья не предлагает календарных услуг, за исключением минимального сопоставления с time_t языка C и обратно.

Поскольку в этом документе не предлагается библиотека даты/времени и не указываются эпохи, в нем также не рассматриваются дополнительные секунды. Однако библиотека даты/времени сочтет это отличным фундаментом, на котором можно строить.

В этой статье не предлагается библиотека физических величин общего назначения.

В этой статье предлагается прочная основа, которая в будущем может стать совместимой отправной точкой для библиотеки общих физических единиц. В то время как такая будущая библиотека может принимать любую из нескольких форм, нынешнее предложение на самом деле не является библиотекой физических модулей. Это предложение привязано ко времени и по-прежнему обусловлено потребностями библиотеки потоков, связанными со временем.

Основная цель этого предложения — удовлетворить потребности API потоковой передачи стандартной библиотеки таким образом, чтобы он был простым в использовании, безопасным в использовании, эффективным и достаточно гибким, чтобы не устаревать через 10 или даже 100 лет. Каждая функция, содержащаяся в этом предложении, здесь по определенной причине с практическими вариантами использования в качестве мотивации. Вещи, которые попали в категорию «круто», или «звучит так, будто это может быть полезно», или «очень полезно, но не нужно для этого интерфейса», не были включены. Такие пункты могут появиться в других предложениях и, возможно, предназначаться для ТР.

Обратите внимание, что основная цель <chrono> — «удовлетворить потребности API потоковой передачи стандартной библиотеки», для которого не требуются службы календаря.

localtime и gmtime имеют статическое внутреннее хранилище, что означает, что они не являются потокобезопасными (мы должны вернуть указатель на структуру данных, поэтому он должен быть выделен либо динамически, либо статическим значением, либо глобальным значением - поскольку динамическое выделение приведет к утечке память, что не является разумным решением, а это означает, что это должна быть глобальная или статическая переменная [теоретически можно было бы выделить и сохранить в TLS и таким образом сделать его потокобезопасным]).

У большинства систем есть альтернативы, ориентированные на многопотоковое исполнение, но они не являются частью стандартной библиотеки. Например, в Linux/Posix есть localtime_r и gmtime_r, которые принимают дополнительный параметр для результата. См., например, http://pubs.opengroup.org/onlinepubs/7908799/xsh/gmtime.html

Точно так же в библиотеках Microsoft есть gmtime_s, который также является реентерабельным и работает аналогичным образом (передавая выходной параметр в качестве входного). См. http://msdn.microsoft.com/en-us/library/3stkd9be.aspx

Почему стандартная библиотека С++ 11 не использует эти функции? Это вы должны спросить у людей, которые написали эту спецификацию - я ожидаю, что это портативность и удобство, но я не совсем уверен.

Нет потокобезопасной альтернативы std::localtime и std::gmtime, потому что вы не предложили ее и не маршалировали через весь процесс стандартизации. И никто другой тоже.

chronoЕдинственный код календаря — это код, обертывающий существующие time_t функции. Стандартизация или написание новых не входило в сферу деятельности проекта chrono. Для такой стандартизации потребуется больше времени, больше усилий и добавление дополнительных зависимостей. Простое обертывание каждой функции time_t было простым, имело мало зависимостей и было быстрым.

Они сконцентрировали свои усилия узко. И они преуспели в том, на чем сосредоточились.

Я призываю вас начать работу над <calendar> или присоединиться к таким усилиям по созданию надежного API календаря для std. Удачи и благодати!

Если вы хотите использовать бесплатную стороннюю библиотеку с открытым исходным кодом, вот способ печати std::chrono::system_clock::time_point в UTC:

#include "date.h"
#include <iostream>

int
main()
{
    using namespace date;
    using namespace std::chrono;
    std::cout << system_clock::now() << " UTC\n";
}

Это потокобезопасная альтернатива std::gmtime с использованием современного синтаксиса C++.

Для современной поточно-ориентированной замены std::localtime вам понадобится тесно связанная библиотека часовых поясов более высокого уровня и синтаксис выглядит так:

#include "tz.h"
#include <iostream>

int
main()
{
    using namespace date;
    using namespace std::chrono;
    std::cout << make_zoned(current_zone(), system_clock::now()) << "\n";
}

Оба они будут выводить с любой точностью, поддерживаемой вашим system_clock, например:

2016-07-05 10:03:01.608080 EDT

(микросекунды в macOS)

Эти библиотеки выходят далеко за рамки замены gmtime и localtime. Например, вы хотите увидеть текущую дату в юлианском календаре?

#include "julian.h"
#include <iostream>

int
main()
{
    using namespace std::chrono;
    std::cout << julian::year_month_day(date::floor<date::days>(system_clock::now())) << "\n";
}

2016-06-22

Как насчет текущего времени GPS?

#include "tz.h"
#include <iostream>

int
main()
{
    using namespace date;
    std::cout << std::chrono::system_clock::now() << " UTC\n";
    std::cout << gps_clock::now() << " GPS\n";
}

2016-07-05 14:13:02.138091 UTC
2016-07-05 14:13:19.138524 GPS

https://github.com/HowardHinnant/date

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0355r0.html

Обновить

Библиотеки «date.h» и «tz.h» теперь находятся в проекте спецификации C++2a с очень небольшими изменениями, и мы надеемся, что «a» равно «0». Они будут жить в шапке <chrono> и под namespace std::chrono (и не будет date namespace).

Как уже упоминалось, на самом деле ни в одном доступном стандарте C++ нет многопоточного удобства и переносимого подхода к форматированию времени, но есть некоторая архаичная техника препроцессора, которую я нашел полезной (спасибо Андрею Александреску на CppCon 2015 слайд 17 и 18):

std::mutex gmtime_call_mutex;

template< size_t For_Separating_Instantiations >
std::tm const * utc_impl( std::chrono::system_clock::time_point const & tp )
{
    thread_local static std::tm tm = {};
    std::time_t const time = std::chrono::system_clock::to_time_t( tp );
    {
        std::unique_lock< std::mutex > ul( gmtime_call_mutex );
        tm = *std::gmtime( &time );
    }
    return &tm;
}


#ifdef __COUNTER__
#define utc( arg ) utc_impl<__COUNTER__>( (arg) )
#else
#define utc( arg ) utc_impl<__LINE__>( (arg) )
#endif 

Здесь мы объявляем функцию с аргументом шаблона size_t и возвращаем указатель на статический член std::tm. Теперь каждый вызов этой функции с другим аргументом шаблона создает новую функцию с совершенно новой статической переменной std::tm. Если определен макрос __COUNTER__, он должен заменяться увеличивающимся целочисленным значением каждый раз, когда он используется, в противном случае мы используем макрос __LINE__ и в этом случае лучше быть уверенным, что мы не вызываем макрос utc дважды в одной строке.

Глобальный gmtime_call_mutex защищает вызов std::gmtime без многопоточности в каждом экземпляре, и, по крайней мере, в Linux не должно быть проблем с производительностью, поскольку получение блокировки сначала выполняется как обход спин-блокировки, и в нашем случае никогда не должно заканчиваться реальной блокировкой потока.

thread_local гарантирует, что разные потоки, выполняющие один и тот же код с вызовами utc, будут по-прежнему работать с разными переменными std::tm.

Пример использования:

void work_with_range(
        std::chrono::system_clock::time_point from = {}
        , std::chrono::system_clock::time_point to = {}
        )
{
    std::cout << "Will work with range from "
         << ( from == decltype(from)()
              ? std::put_time( nullptr, "beginning" )
              : std::put_time( utc( from ), "%Y-%m-%d %H:%M:%S" )
            )
         << " to "
         << ( to == decltype(to)()
              ? std::put_time( nullptr, "end" )
              : std::put_time( utc( to ), "%Y-%m-%d %H:%M:%S" )
            )
         << "."
         << std::endl;
    // ...
}

Boost: не совсем уверен, что это потокобезопасно, но похоже:

#include "boost/date_time/posix_time/posix_time.hpp"

std::wstring stamp = boost::posix_time::to_iso_wstring(
    boost::posix_time::second_clock::local_time());
std::wstring stamp = boost::posix_time::to_iso_wstring(
    boost::posix_time::second_clock::universal_time());

См. https://www.boost.org/doc/libs/1_75_0/doc/html/date_time/examples.html