Represents a running thread. More...
#include <glibmm/threads.h>
|
class | Exit |
| Exception class used to exit from a thread. More...
|
|
|
void | join () |
| Waits until the thread finishes.
|
|
GThread* | gobj () |
|
const GThread* | gobj () const |
|
|
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.
|
|
|
(Note that these are not member functions.)
|
Thread* | wrap (GThread* gobject) |
|
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.
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
-
- 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.