src/thread.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file thread.h Base of all threads. */
   9
  10 #ifndef THREAD_H
  11 #define THREAD_H
  12
  13 #include "debug.h"
  14 #include "crashlog.h"
  15 #include <system_error>
  16 #include <thread>
  17 #include <mutex>
  18
  19 /**
  20  * Sleep on the current thread for a defined time.
  21  * @param milliseconds Time to sleep for in milliseconds.
  22  */
  23 inline void CSleep(int milliseconds)
  24 {
  25         std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
  26 }
  27
  28 /**
  29  * Name the thread this function is called on for the debugger.
  30  * @param name Name to set for the thread..
  31  */
  32 void SetCurrentThreadName(const char *name);
  33
  34
  35 /**
  36  * Start a new thread.
  37  * @tparam TFn Type of the function to call on the thread.
  38  * @tparam TArgs Type of the parameters of the thread function.
  39  * @param thr Pointer to a thread object; may be \c nullptr if a detached thread is wanted.
  40  * @param name Name of the thread.
  41  * @param _Fx Function to call on the thread.
  42  * @param _Ax Arguments for the thread function.
  43  * @return True if the thread was successfully started, false otherwise.
  44  */
  45 template<class TFn, class... TArgs>
  46 inline bool StartNewThread(std::thread *thr, const char *name, TFn&& _Fx, TArgs&&... _Ax)
  47 {
  48 #ifndef NO_THREADS
  49         try {
  50                 static std::mutex thread_startup_mutex;
  51                 std::lock_guard<std::mutex> lock(thread_startup_mutex);
  52
  53                 std::thread t([] (const char *name, TFn&& F, TArgs&&... A) {
  54                                 /* Delay starting the thread till the main thread is finished
  55                                  * with the administration. This prevent race-conditions on
  56                                  * startup. */
  57                                 {
  58                                         std::lock_guard<std::mutex> lock(thread_startup_mutex);
  59                                 }
  60
  61                                 SetCurrentThreadName(name);
  62                                 CrashLog::InitThread();
  63                                 try {
  64                                         /* Call user function with the given arguments. */
  65                                         F(A...);
  66                                 } catch (...) {
  67                                         NOT_REACHED();
  68                                 }
  69                         }, name, std::forward<TFn>(_Fx), std::forward<TArgs>(_Ax)...);
  70
  71                 if (thr != nullptr) {
  72                         *thr = std::move(t);
  73                 } else {
  74                         t.detach();
  75                 }
  76
  77                 return true;
  78         } catch (const std::system_error& e) {
  79                 /* Something went wrong, the system we are running on might not support threads. */
  80                 Debug(misc, 1, "Can't create thread '{}': {}", name, e.what());
  81         }
  82 #endif
  83
  84         return false;
  85 }
  86
  87 #endif /* THREAD_H */