glibmm: Glib::Threads::Thread Class Reference

glibmm 2.32.1

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Examples

- Class List
- Class Index
- Class Hierarchy
- Class Members

Classes | Public Member Functions | Static Public Member Functions | Related Functions
Glib::Threads::Thread Class Reference
Threads

Represents a running thread. More...

`#include <glibmm/threads.h>`

List of all members.

## Classes
class | Exit
| Exception class used to exit from a thread. More...

## Public Member Functions
void | join ()
| Waits until the thread finishes.
GThread* | gobj ()
const GThread* | gobj () const

## Static Public Member Functions
static Thread* | create (const sigc::slot< void >& slot)
| Creates a new thread.
static Thread* | self ()
| Returns the Thread* corresponding to the calling thread.
static void | yield ()
| Gives way to other threads waiting to be scheduled.

## Related Functions
(Note that these are not member functions.)
Thread* | wrap (GThread* gobject)

## Detailed Description

Represents a running thread.

An instance of this class can only be obtained with create(), self(), or wrap(GThread*). It's not possible to delete a Thread object. You must call join() to avoid a memory leak.

Note:
  g_thread_exit() is not wrapped, because that function exits a thread without any cleanup. That's especially dangerous in C++ code, since the destructors of automatic objects won't be invoked. Instead, you can throw a Threads::Thread::Exit exception, which will be caught by the internal thread entry function.
  You might have noticed that the thread entry slot doesn't have the usual void* return value. If you want to return any data from your thread you can pass an additional output argument to the thread's entry slot.

Examples:
  thread/dispatcher.cc, and thread/thread.cc.

## Member Function Documentation

static Thread* Glib::Threads::Thread::create | ( | const sigc::slot< void > & | slot | ) |
| static

Creates a new thread.

You can wait for this thread's termination by calling join().

The new thread executes the function or method slot points to. You can pass additional arguments using sigc::bind(). If the thread was created successfully, it is returned, otherwise a Threads::ThreadError exception is thrown.

Because sigc::trackable is not thread safe, if the slot represents a non-static class method (that is, it is created by sigc::mem_fun()), the class concerned should not derive from sigc::trackable.

Parameters:

  slot | A slot to execute in the new thread.

Returns:
  The new Thread* on success.

Exceptions:

  Glib::Threads::ThreadError |

Examples:
  thread/dispatcher.cc, and thread/thread.cc.

GThread* Glib::Threads::Thread::gobj | ( |  | ) |
| inline

const GThread* Glib::Threads::Thread::gobj | ( |  | ) | const
| inline

void Glib::Threads::Thread::join | ( |  | ) |

Waits until the thread finishes.

Waits until the thread finishes, i.e. the slot, as given to create(), returns or g_thread_exit() is called by the thread. (Calling g_thread_exit() in a C++ program should be avoided.) All resources of the thread including the Glib::Threads::Thread object are released.

Examples:
  thread/thread.cc.

static Thread* Glib::Threads::Thread::self | ( |  | ) |
| static

Returns the Thread* corresponding to the calling thread.

Returns:
  The current thread.

static void Glib::Threads::Thread::yield | ( |  | ) |
| static

Gives way to other threads waiting to be scheduled.

This function is often used as a method to make busy wait less evil. But in most cases, you will encounter, there are better methods to do that. So in general you shouldn't use this function.