glibmm: Glib::Threads::Thread Class Reference

glibmm 2.31.16.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
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, bool joinable=true)
| Creates a new thread with the priority `THREAD_PRIORITY_NORMAL`.
static Thread* | self ()
| Returns the Thread* corresponding to the calling thread.
static void | yield ()
| Gives way to other threads waiting to be scheduled.

## 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. If the thread is not joinable, its resources will be freed automatically when it exits. Otherwise, if the thread is joinable, 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 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,
|  | bool | joinable = `true`
| ) |  | `[static]`

Creates a new thread with the priority `THREAD_PRIORITY_NORMAL`.

If joinable is `true`, you can wait for this thread's termination by calling join(). Otherwise the thread will just disappear, when ready.

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 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.
  joinable | This parameter is now ignored because Threads are now always joinable.

Returns:
  The new Thread* on success.

Exceptions:

  Glib::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::Thread object are released. The thread must have been created with `joinable = true`.

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.