thread.h

Go to the documentation of this file.

/*
  Copyright (c) Mircea Neacsu (2014-2025) Licensed under MIT License.
  This file is part of MLIB project. See LICENSE file for full license terms.
*/

 
#pragma once
 
#include "event.h"
#include <functional>
 
namespace mlib {

class thread : public syncbase
{
public:

  enum class state
  {
    ready,        
    starting,     
    running,      
    ending,       
    finished      
  };

  thread (std::function<unsigned int ()> func);
 
  virtual ~thread ();

  virtual void start ();

  void fork ();

  void join ();

  DWORD wait (DWORD time_limit = INFINITE);

  DWORD wait_alertable (DWORD time_limit = INFINITE);

  DWORD wait_msg (DWORD time_limit = INFINITE, DWORD mask = QS_ALLINPUT);

  void rethrow_exception () const;

  DWORD id () const;

  UINT result () const;

  bool is_running () const;

  state get_state () const;

  int priority () const;

  void priority (int pri);
 
  using syncbase::name;

  virtual void name (const std::string& nam);
 
protected:
  thread (const std::string& name = std::string (), DWORD stack_size = 0,
          PSECURITY_DESCRIPTOR sd = NULL, bool inherit = false);

  virtual bool init ();

  virtual void term ();

  virtual void run ();
 
  unsigned int exitcode; 
 
private:
  void initialize (PSECURITY_DESCRIPTOR sd, BOOL inherit);
  thread& operator= (const thread& t) = delete;
  thread (const thread& t) = delete;
 
  DWORD id_;
  state volatile stat;
  auto_event created, started;
  static unsigned int _stdcall entryProc (thread* ts);
  DWORD stack;
  std::function<unsigned int ()> thfunc;
  std::exception_ptr pex;
};

class current_thread
{
public:
  DWORD id () const;      
  HANDLE handle () const; 
  int priority ();        
  void priority (int pri); 
};
 
// inlines
 
inline void thread::fork ()
{
  start ();
}
 
inline void thread::join ()
{
  wait (INFINITE);
}
 
inline DWORD thread::id () const
{
  return id_;
};
 
inline UINT thread::result () const
{
  return exitcode;
}
 
inline bool thread::is_running () const
{
  return stat == state::running;
}
 
inline thread::state thread::get_state () const
{
  return stat;
}
 
inline int thread::priority () const
{
  return GetThreadPriority (handle ());
}
 
inline void thread::priority (int pri)
{
  SetThreadPriority (handle (), pri);
}
 
inline bool thread::init ()
{
  return true;
}
 
inline void thread::term ()
{
}
 
inline void thread::rethrow_exception () const
{
  if (pex)
    std::rethrow_exception (pex);
}
 
// ----------- current_thread inline functions ------------------------------

inline DWORD current_thread::id () const
{
  return GetCurrentThreadId ();
}
 
inline HANDLE current_thread::handle () const
{
  return GetCurrentThread ();
}

inline int current_thread::priority ()
{
  return GetThreadPriority (GetCurrentThread ());
}

inline void current_thread::priority (int pri)
{
  SetThreadPriority (GetCurrentThread (), pri);
}

 
template <typename T>
concept ThreadDerived = std::derived_from<T, mlib::thread>;
 
template <ThreadDerived T>
inline DWORD wait_all (const T* objs, int count, DWORD msec = INFINITE)
{
  assert (count < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  for (int i = 0; i < count; i++)
    harr[i] = objs[i].handle ();
 
  DWORD result = WaitForMultipleObjects (count, harr, true, msec);
  if (result < WAIT_OBJECT_0 + count)
  {
    for (int i = 0; i < count; i++)
      objs[i].rethrow_exception ();
  }
 
  return result;
}
 
template <ThreadDerived T>
inline DWORD wait_all (std::initializer_list<const T*> objs, std::chrono::milliseconds limit)
{
  assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  int i = 0;
  for (auto& th : objs)
    harr[i++] = th->handle ();
 
  DWORD msec = (DWORD)limit.count ();
  DWORD result = WaitForMultipleObjects ((DWORD)objs.size (), harr, true, msec);
  if (result < WAIT_OBJECT_0 + objs.size ())
  {
    for (auto& th : objs)
      th->rethrow_exception ();
  }
 
  return result;
}
 
template <ThreadDerived T>
inline DWORD wait_all (std::initializer_list<const T*> objs, DWORD msec = INFINITE)
{
  assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  int i = 0;
  for (auto& th : objs)
    harr[i++] = th->handle ();
 
  DWORD result = WaitForMultipleObjects ((DWORD)objs.size (), harr, true, msec);
  if (result < WAIT_OBJECT_0 + objs.size ())
  {
    for (auto& th : objs)
      th->rethrow_exception ();
  }
 
  return result;
}
 
template <ThreadDerived T>
inline DWORD wait_any (const T* objs, int count, DWORD msec = INFINITE)
{
  assert (count < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  for (int i = 0; i < count; i++)
    harr[i] = objs[i].handle ();
 
  DWORD result = WaitForMultipleObjects (count, harr, false, msec);
  if (result < WAIT_OBJECT_0 + count)
  {
    for (int i = 0; i < count; i++)
      objs[i].rethrow_exception ();
  }
  return result;
}
 
template <ThreadDerived T>
inline DWORD wait_any (std::initializer_list<const T*> objs, DWORD msec = INFINITE)
{
  assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  int i = 0;
  for (auto& th : objs)
    harr[i++] = th->handle ();
 
  DWORD result = WaitForMultipleObjects ((DWORD)objs.size (), harr, false, msec);
  if (result < WAIT_OBJECT_0 + objs.size ())
  {
    for (auto& th : objs)
      th->rethrow_exception ();
  }
  return result;
}
 
template <ThreadDerived T>
inline DWORD wait_any (std::initializer_list<const T*> objs, std::chrono::milliseconds timeout)
{
  assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  int i = 0;
  for (auto& th : objs)
    harr[i++] = th->handle ();
  DWORD msec = (DWORD)timeout.count ();
  DWORD result = WaitForMultipleObjects ((DWORD)objs.size (), harr, false, msec);
  if (result < WAIT_OBJECT_0 + objs.size ())
  {
    for (auto& th : objs)
      th->rethrow_exception ();
  }
  return result;
}
 
template <ThreadDerived T>
inline DWORD wait_msg (const T* objs, int count, bool all = true, DWORD msec = INFINITE,
                       DWORD mask = QS_ALLINPUT)
{
  assert (count < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  for (int i = 0; i < count; i++)
    harr[i] = objs[i].handle ();
 
  DWORD result = MsgWaitForMultipleObjects (count, harr, all, msec, mask);
  if (result < WAIT_OBJECT_0 + count)
  {
    for (int i = 0; i < count; i++)
      objs[i].rethrow_exception ();
  }
  return result;
}
 
template <ThreadDerived T>
inline DWORD wait_msg (std::initializer_list<const T*> objs, bool all = true, DWORD msec = INFINITE,
                       DWORD mask = QS_ALLINPUT)
{
  assert (objs.size () < MAXIMUM_WAIT_OBJECTS);
  HANDLE harr[MAXIMUM_WAIT_OBJECTS];
  int i = 0;
  for (auto& th : objs)
    harr[i++] = th->handle ();
 
  DWORD result = MsgWaitForMultipleObjects ((DWORD)objs.size (), harr, all, msec, mask);
  if (result < WAIT_OBJECT_0 + objs.size ())
  {
    for (auto& th : objs)
      th->rethrow_exception ();
  }
  return result;
}

 
} // namespace mlib