Name
Thread Pools — pools of threads to execute work concurrently.
Library
glib.lib
Synopsis
#include <glib.h>
GThreadPool;
GThreadPool* g_thread_pool_new (GFunc func, gpointer user_data, gint max_threads, gboolean exclusive, GError **error);
void g_thread_pool_push (GThreadPool *pool, gpointer data, GError **error);
void g_thread_pool_set_max_threads (GThreadPool *pool, gint max_threads, GError **error);
gint g_thread_pool_get_max_threads (GThreadPool *pool);
guint g_thread_pool_get_num_threads (GThreadPool *pool);
guint g_thread_pool_unprocessed (GThreadPool *pool);
void g_thread_pool_free (GThreadPool *pool, gboolean immediate, gboolean wait);
void g_thread_pool_set_max_unused_threads (gint max_threads);
gint g_thread_pool_get_max_unused_threads (void);
guint g_thread_pool_get_num_unused_threads (void);
void g_thread_pool_stop_unused_threads (void);
void g_thread_pool_set_sort_function (GThreadPool *pool, GCompareDataFunc func, gpointer user_data); void g_thread_pool_set_max_idle_time (guint interval); guint g_thread_pool_get_max_idle_time (void);
Detailed Description
If the need to asynchronously fork out the execution of work and continue working within the own thread happens often, the overhead of starting and destroying a thread each time might be too high. In such cases reusing already started threads seems like a good idea. And it indeed is, but implementing this can be tedious and error-prone.
Therefore GLib provides thread pools for convenience. An added advantage is, that the threads can be shared between the different subsystems of the program, when they are using GLib.
To create a new thread pool, use
g_thread_pool_new(). It is destroyed by g_thread_pool_free().
To execute a certain task within a thread pool, call
g_thread_pool_push().
To get the current number of running threads call
g_thread_pool_get_num_threads(). To get the number
of still unprocessed tasks call g_thread_pool_unprocessed(). To control the maximal
number of threads for a thread pool, use
g_thread_pool_get_max_threads() and g_thread_pool_set_max_threads().
The number of unused threads, that are kept alive by GLib for future use can be
controlled. The current number can be fetched with
g_thread_pool_get_num_unused_threads(). The maximal
number can be controlled by g_thread_pool_get_max_unused_threads() and
g_thread_pool_set_max_unused_threads(). All
currently unused threads can be stopped by calling g_thread_pool_stop_unused_threads().
Details
GThreadPool
typedef struct {
GFunc func;
gpointer user_data;
gboolean exclusive;
} GThreadPool;
The GThreadPool struct represents a thread pool. It has six public read-only members, but the underlying struct is bigger, so do not copy this struct.
g_thread_pool_new ()
GThreadPool* g_thread_pool_new (GFunc func, gpointer user_data, gint max_threads, gboolean exclusive, GError **error);
This function creates a new thread pool.
Whenever the function g_thread_pool_push()
is called, either a new thread is
created or an unused one is reused. At most,
max_threads
threads are running concurrently for this thread pool.
max_threads
= -1 allows unlimited threads to be created for this thread pool. The newly
created or reused thread now executes the function func with the two arguments. The first one
is the parameter to
g_thread_pool_push() and the second one is
user_data.
The parameter exclusive
determines, whether the thread pool owns all threads exclusive or whether the
threads are shared globally. If exclusive
is TRUE,
max_threads
threads are started immediately and they will run exclusively for this thread
pool until it is destroyed by g_thread_pool_free(). If exclusive is
FALSE, threads are
created, when needed and shared between all non-exclusive thread pools. This
implies that max_threads
may not be -1 for exclusive thread pools.
error can be NULL
to ignore errors, or non-NULL
to report errors. An error can only occur when
exclusive
is set to TRUE
and not all max_threads threads could be
created.
func : |
a function to execute in the threads of the new thread pool |
user_data : |
user data that is handed over to func
every time it is called
|
max_threads : |
the maximal number of threads to execute concurrently in the new thread pool, -1 means no limit |
exclusive : |
should this thread pool be exclusive? |
error : |
return location for error |
| Returns : | the new GThreadPool |
g_thread_pool_push ()
void g_thread_pool_push (GThreadPool *pool, gpointer data, GError **error);
Inserts data into the list of tasks to
be executed by pool. When the number of
currently running threads is lower than the maximal allowed number of threads, a
new thread is started (or reused) with the properties given to
g_thread_pool_new(). Otherwise data
stays in the queue until a thread in this pool finishes its previous task and
processes data.
error can be NULL
to ignore errors, or non-NULL
to report errors. An error can only occur when a new thread could no t be created.
In that case data is simply appended to
the queue of work to do.
pool : |
a GThreadPool |
data : |
a new task for pool
|
error : |
return location for error |
g_thread_pool_set_max_threads ()
void g_thread_pool_set_max_threads (GThreadPool *pool, gint max_threads, GError **error);
Sets the maximal allowed number of threads for pool.
A value of -1 means, that the maximal number of threads is unlimited.
Setting max_threads to 0 means stopping
all work for pool. It is effectively
frozen until max_threads
is set to a non-zero value again.
A thread is never terminated while calling func,
as supplied by
g_thread_pool_new(). Instead the maximal number of
threads only has effect for the allocation of new threads in
g_thread_pool_push(). A new thread is allocated, whenever the number
of currently running threads in pool is
smaller than the maximal number.
error can be NULL
to ignore errors, or non-NULL to report errors. An error can only occur when a
new thread could not be created.
pool : |
a GThreadPool |
max_threads : |
a new maximal number of threads for pool
|
error : |
return location for error |
g_thread_pool_get_max_threads ()
gint g_thread_pool_get_max_threads (GThreadPool *pool);
Returns the maximal number of threads for pool.
pool : |
a GThreadPool |
| Returns : | the maximal number of threads |
g_thread_pool_get_num_threads ()
guint g_thread_pool_get_num_threads (GThreadPool *pool);
Returns the number of threads currently running in pool.
pool : |
a GThreadPool |
| Returns : | the number of threads currently running |
g_thread_pool_unprocessed ()
guint g_thread_pool_unprocessed (GThreadPool *pool);
Returns the number of tasks still unprocessed in
pool.
pool : |
a GThreadPool |
| Returns : | the number of unprocessed tasks |
g_thread_pool_free ()
void g_thread_pool_free (GThreadPool *pool, gboolean immediate, gboolean wait);
Frees all resources allocated for pool.
If immediate is TRUE,
no new task is processed for
pool. Otherwise pool is not freed before the last task is
processed. Note however, that no thread of this pool is interrupted, while
processing a task. Instead at least all still running threads can finish their
tasks before the pool
is freed.
If wait is TRUE,
the functions does not return before all tasks to be processed (dependent on
immediate, whether all or only the currently running) are ready.
Otherwise the function returns immediately.
After calling this function pool
must not be used anymore.
pool : |
a GThreadPool |
immediate : |
should pool shut down
immediately?
|
wait : |
should the function wait for all tasks to be finished? |
g_thread_pool_set_max_unused_threads ()
void g_thread_pool_set_max_unused_threads (gint max_threads);
Sets the maximal number of unused threads to
max_threads. If
max_threads is -1, no limit is imposed
on the number of unused threads.
max_threads : |
maximal number of unused threads |
g_thread_pool_get_max_unused_threads ()
gint g_thread_pool_get_max_unused_threads (void);
Returns the maximal allowed number of unused threads.
| Returns : | the maximal number of unused threads |
g_thread_pool_get_num_unused_threads ()
guint g_thread_pool_get_num_unused_threads (void);
Returns the number of currently unused threads.
| Returns : | the number of currently unused threads |
g_thread_pool_stop_unused_threads ()
void g_thread_pool_stop_unused_threads (void);
Stops all currently unused threads. This does not change the maximal number of
unused threads. This function can be used to regularly stop all unused threads
e.g. from g_timeout_add().
g_thread_pool_set_sort_function ()
void g_thread_pool_set_sort_function (GThreadPool *pool, GCompareDataFunc func, gpointer user_data);
Sets the function used to sort the list of tasks. This allows the tasks to be
processed by a priority determined by func,
and not just in the order in which they were added to the pool.
Note, if the maximum number of threads is more than 1, the order that threads are executed can not be guaranteed 100%. Threads are scheduled by the operating system and are executed at random. It cannot be assumed that threads are executed in the order they are created.
pool : |
a GThreadPool |
func : |
the GCompareDataFunc used to sort the list of tasks. This function is passed two tasks. It should return 0 if the order in which they are handled does not matter, a negative value if the first task should be processed before the second or a positive value if the second task should be processed first. |
user_data : |
user data passed to func.
|
g_thread_pool_set_max_idle_time ()
void g_thread_pool_set_max_idle_time (guint interval);
This function will set the maximum interval
that a thread waiting in the pool for new tasks can be idle for before being
stopped. This function is similar to calling
g_thread_pool_stop_unused_threads() on a regular timeout, except,
this is done on a per thread basis.
By setting interval to 0, idle threads
will not be stopped. This function makes use of
g_async_queue_timed_pop() using
interval.
interval : |
the maximum interval (1/1000ths of
a second) a thread can be idle.
|
g_thread_pool_get_max_idle_time ()
guint g_thread_pool_get_max_idle_time (void);
This function will return the maximum interval
that a thread will wait in the thread pool for new tasks before being stopped.
If this function returns 0, threads waiting in the thread pool for new work are not stopped.
| Returns : | the maximum interval to wait for
new tasks in the thread pool before stopping the thread (1/1000ths of a second).
|
See Also
|
© 2005-2007 Nokia |
|
