* Boston, MA 02111-1307, USA.
*/
+/* {{{1 Prelude */
/* Prelude {{{1 ----------------------------------------------------------- */
/*
#include "config.h"
-#include "gthread.h"
+#include "deprecated/gthread.h"
#include "gthreadprivate.h"
#include "gslice.h"
#include "gmain.h"
/**
* SECTION:threads
* @title: Threads
- * @short_description: thread abstraction; including threads, different
- * mutexes, conditions and thread private data
+ * @short_description: portable support for threads, mutexes, locks,
+ * conditions and thread private data
* @see_also: #GThreadPool, #GAsyncQueue
*
* Threads act almost like processes, but unlike processes all threads
* threads can be made, unless order is explicitly forced by the
* programmer through synchronization primitives.
*
- * The aim of the thread related functions in GLib is to provide a
+ * The aim of the thread-related functions in GLib is to provide a
* portable means for writing multi-threaded software. There are
* primitives for mutexes to protect the access to portions of memory
- * (#GMutex, #GStaticMutex, #G_LOCK_DEFINE, #GStaticRecMutex and
- * #GStaticRWLock). There is a facility to use individual bits for
- * locks (g_bit_lock()). There are primitives for condition variables to
- * allow synchronization of threads (#GCond). There are primitives for
- * thread-private data - data that every thread has a private instance
- * of (#GPrivate, #GStaticPrivate). There are facilities for one-time
- * initialization (#GOnce, g_once_init_enter()). Last but definitely
- * not least there are primitives to portably create and manage
- * threads (#GThread).
+ * (#GMutex, #GRecMutex and #GRWLock). There is a facility to use
+ * individual bits for locks (g_bit_lock()). There are primitives
+ * for condition variables to allow synchronization of threads (#GCond).
+ * There are primitives for thread-private data - data that every thread
+ * has a private instance of (#GPrivate, #GStaticPrivate). There are
+ * facilities for one-time initialization (#GOnce, g_once_init_enter()).
+ * Finally there are primitives to create and manage threads (#GThread).
*
* The threading system is initialized with g_thread_init(), which
* takes an optional custom thread implementation or %NULL for the
*
* Please note that since version 2.24 the GObject initialization
* function g_type_init() initializes threads (with a %NULL argument),
- * so most applications, including those using Gtk+ will run with
+ * so most applications, including those using GTK+ will run with
* threads enabled. If you want a special thread implementation, make
* sure you call g_thread_init() before g_type_init() is called.
*
* global data is automatically locked), but individual data structure
* instances are not automatically locked for performance reasons. So,
* for example you must coordinate accesses to the same #GHashTable
- * from multiple threads. The two notable exceptions from this rule
+ * from multiple threads. The two notable exceptions from this rule
* are #GMainLoop and #GAsyncQueue, which <emphasis>are</emphasis>
* threadsafe and need no further application-level locking to be
* accessed from multiple threads.
- *
- * To help debugging problems in multithreaded applications, GLib
- * supports error-checking mutexes that will give you helpful error
- * messages on common problems. To use error-checking mutexes, define
- * the symbol #G_ERRORCHECK_MUTEXES when compiling the application.
- **/
+ */
/**
* G_THREADS_IMPL_POSIX:
*
* This macro is defined if POSIX style threads are used.
- **/
+ */
/**
- * G_THREADS_ENABLED:
+ * G_THREADS_IMPL_WIN32:
*
- * This macro is defined, for backward compatibility, to indicate that
- * GLib has been compiled with thread support. As of glib 2.28, it is
- * always defined.
- **/
+ * This macro is defined if Windows style threads are used.
+ */
/**
- * G_THREADS_IMPL_NONE:
+ * G_THREADS_ENABLED:
*
- * This macro is defined if no thread implementation is used. You can,
- * however, provide one to g_thread_init() to make GLib multi-thread
- * safe.
+ * This macro is defined, for backward compatibility, to indicate that
+ * GLib has been compiled with thread support. As of GLib 2.28, it is
+ * always defined.
**/
/* G_LOCK Documentation {{{1 ---------------------------------------------- */
* #G_LOCK_DEFINE.
**/
-/* GThreadError {{{1 ------------------------------------------------------- */
-/**
- * GThreadError:
- * @G_THREAD_ERROR_AGAIN: a thread couldn't be created due to resource
- * shortage. Try again later.
- *
- * Possible errors of thread related functions.
- **/
-
-/**
- * G_THREAD_ERROR:
- *
- * The error domain of the GLib thread subsystem.
- **/
-GQuark
-g_thread_error_quark (void)
-{
- return g_quark_from_static_string ("g_thread_error");
-}
-
-/* Miscellaneous Structures {{{1 ------------------------------------------ */
-typedef struct _GRealThread GRealThread;
-struct _GRealThread
-{
- GThread thread;
- /* Bit 0 protects private_data. To avoid deadlocks, do not block while
- * holding this (particularly on the g_thread lock). */
- volatile gint private_data_lock;
- GArray *private_data;
- GRealThread *next;
- gpointer retval;
- GSystemThread system_thread;
-};
-
-#define LOCK_PRIVATE_DATA(self) g_bit_lock (&(self)->private_data_lock, 0)
-#define UNLOCK_PRIVATE_DATA(self) g_bit_unlock (&(self)->private_data_lock, 0)
-
-typedef struct _GStaticPrivateNode GStaticPrivateNode;
-struct _GStaticPrivateNode
-{
- gpointer data;
- GDestroyNotify destroy;
-};
-
-static void g_thread_cleanup (gpointer data);
-static void g_thread_fail (void);
-static guint64 gettime (void);
-
-guint64 (*g_thread_gettime) (void) = gettime;
-
-/* Global Variables {{{1 -------------------------------------------------- */
-
-static GSystemThread zero_thread; /* This is initialized to all zero */
-gboolean g_thread_use_default_impl = TRUE;
-
-/**
- * g_thread_supported:
- * @Returns: %TRUE, if the thread system is initialized.
- *
- * This function returns %TRUE if the thread system is initialized, and
- * %FALSE if it is not.
- *
- * <note><para>This function is actually a macro. Apart from taking the
- * address of it you can however use it as if it was a
- * function.</para></note>
- **/
-
-/* IMPLEMENTATION NOTE:
- *
- * g_thread_supported() is just returns g_threads_got_initialized
- */
-gboolean g_threads_got_initialized = FALSE;
-
-/* Thread Implementation Virtual Function Table {{{1 ---------------------- */
-/* Virtual Function Table Documentation {{{2 ------------------------------ */
-/**
- * GThreadFunctions:
- * @mutex_new: virtual function pointer for g_mutex_new()
- * @mutex_lock: virtual function pointer for g_mutex_lock()
- * @mutex_trylock: virtual function pointer for g_mutex_trylock()
- * @mutex_unlock: virtual function pointer for g_mutex_unlock()
- * @mutex_free: virtual function pointer for g_mutex_free()
- * @cond_new: virtual function pointer for g_cond_new()
- * @cond_signal: virtual function pointer for g_cond_signal()
- * @cond_broadcast: virtual function pointer for g_cond_broadcast()
- * @cond_wait: virtual function pointer for g_cond_wait()
- * @cond_timed_wait: virtual function pointer for g_cond_timed_wait()
- * @cond_free: virtual function pointer for g_cond_free()
- * @private_new: virtual function pointer for g_private_new()
- * @private_get: virtual function pointer for g_private_get()
- * @private_set: virtual function pointer for g_private_set()
- * @thread_create: virtual function pointer for g_thread_create()
- * @thread_yield: virtual function pointer for g_thread_yield()
- * @thread_join: virtual function pointer for g_thread_join()
- * @thread_exit: virtual function pointer for g_thread_exit()
- * @thread_set_priority: virtual function pointer for
- * g_thread_set_priority()
- * @thread_self: virtual function pointer for g_thread_self()
- * @thread_equal: used internally by recursive mutex locks and by some
- * assertion checks
- *
- * This function table is used by g_thread_init() to initialize the
- * thread system. The functions in the table are directly used by their
- * g_* prepended counterparts (described in this document). For
- * example, if you call g_mutex_new() then mutex_new() from the table
- * provided to g_thread_init() will be called.
- *
- * <note><para>Do not use this struct unless you know what you are
- * doing.</para></note>
- **/
-
-/* IMPLEMENTATION NOTE:
- *
- * g_thread_functions_for_glib_use is a global symbol that gets used by
- * most of the "primitive" threading calls. g_mutex_lock(), for
- * example, is just a macro that calls the appropriate virtual function
- * out of this table.
- *
- * For that reason, all of those macros are documented here.
- */
-static GThreadFunctions g_thread_functions_for_glib_use_old = {
-/* GMutex Virtual Functions {{{2 ------------------------------------------ */
+/* GMutex Documentation {{{1 ------------------------------------------ */
/**
* GMutex:
* </programlisting>
* </example>
*
- * #GStaticMutex provides a simpler and safer way of doing this.
+ * A statically initialized #GMutex provides an even simpler and safer
+ * way of doing this:
+ *
+ * <example>
+ * <title>Using a statically allocated mutex</title>
+ * <programlisting>
+ * int
+ * give_me_next_number (void)
+ * {
+ * static GMutex mutex = G_MUTEX_INIT;
+ * static int current_number = 0;
+ * int ret_val;
+ *
+ * g_mutex_lock (&mutex);
+ * ret_val = current_number = calc_next_number (current_number);
+ * g_mutex_unlock (&mutex);
*
- * If you want to use a mutex, and your code should also work without
- * calling g_thread_init() first, then you cannot use a #GMutex, as
- * g_mutex_new() requires that the thread system be initialized. Use a
- * #GStaticMutex instead.
+ * return ret_val;
+ * }
+ * </programlisting>
+ * </example>
*
- * A #GMutex should only be accessed via the following functions.
+ * A #GMutex should only be accessed via <function>g_mutex_</function>
+ * functions.
**/
-
- (GMutex*(*)())g_thread_fail,
- NULL,
- NULL,
- NULL,
- NULL,
-
-/* GCond Virtual Functions {{{2 ------------------------------------------ */
+
+/* GCond Documentation {{{1 ------------------------------------------ */
/**
* GCond:
* </programlisting>
* </example>
*
- * Whenever a thread calls <function>pop_data()</function> now, it will
- * wait until current_data is non-%NULL, i.e. until some other thread
- * has called <function>push_data()</function>.
+ * Whenever a thread calls pop_data() now, it will wait until
+ * current_data is non-%NULL, i.e. until some other thread
+ * has called push_data().
*
* <note><para>It is important to use the g_cond_wait() and
* g_cond_timed_wait() functions only inside a loop which checks for the
* A #GCond should only be accessed via the following functions.
*/
- (GCond*(*)())g_thread_fail,
- NULL,
- NULL,
- NULL,
- NULL,
- NULL,
-
-/* GPrivate Virtual Functions {{{2 --------------------------------------- */
+/* GPrivate Documentation {{{1 --------------------------------------- */
/**
* GPrivate:
* use them as if they were functions.</para></note>
**/
- (GPrivate*(*)(GDestroyNotify))g_thread_fail,
- NULL,
- NULL,
-
-/* GThread Virtual Functions {{{2 ---------------------------------------- */
+/* GThread Documentation {{{1 ---------------------------------------- */
/**
* GThread:
*
* g_thread_create() or g_thread_create_full().
**/
+/* GThreadError {{{1 ------------------------------------------------------- */
/**
- * GThreadPriority:
- * @G_THREAD_PRIORITY_LOW: a priority lower than normal
- * @G_THREAD_PRIORITY_NORMAL: the default priority
- * @G_THREAD_PRIORITY_HIGH: a priority higher than normal
- * @G_THREAD_PRIORITY_URGENT: the highest priority
+ * GThreadError:
+ * @G_THREAD_ERROR_AGAIN: a thread couldn't be created due to resource
+ * shortage. Try again later.
*
- * Deprecated:2.32: thread priorities no longer have any effect.
+ * Possible errors of thread related functions.
**/
- (void(*)(GThreadFunc, gpointer, gulong,
- gboolean, gboolean, GThreadPriority,
- gpointer, GError**))g_thread_fail,
+/**
+ * G_THREAD_ERROR:
+ *
+ * The error domain of the GLib thread subsystem.
+ **/
+GQuark
+g_thread_error_quark (void)
+{
+ return g_quark_from_static_string ("g_thread_error");
+}
+
+/* Miscellaneous Structures {{{1 ------------------------------------------ */
- NULL, /* thread_yield */
- NULL, /* thread_join */
- NULL, /* thread_exit */
- NULL, /* thread_set_priority */
- NULL, /* thread_self */
- NULL /* thread_equal */
+typedef struct _GRealThread GRealThread;
+struct _GRealThread
+{
+ GThread thread;
+ /* Bit 0 protects private_data. To avoid deadlocks, do not block while
+ * holding this (particularly on the g_thread lock). */
+ volatile gint private_data_lock;
+ GArray *private_data;
+ GRealThread *next;
+ gpointer retval;
+ GSystemThread system_thread;
};
+#define LOCK_PRIVATE_DATA(self) g_bit_lock (&(self)->private_data_lock, 0)
+#define UNLOCK_PRIVATE_DATA(self) g_bit_unlock (&(self)->private_data_lock, 0)
+
+static void g_thread_cleanup (gpointer data);
+
+/**
+ * g_thread_supported:
+ * @Returns: %TRUE, if the thread system is initialized.
+ *
+ * This function returns %TRUE if the thread system is initialized, and
+ * %FALSE if it is not.
+ *
+ * <note><para>This function is actually a macro. Apart from taking the
+ * address of it you can however use it as if it was a
+ * function.</para></note>
+ **/
/* Local Data {{{1 -------------------------------------------------------- */
-static GMutex g_once_mutex = G_MUTEX_INIT;
+gboolean g_threads_got_initialized = FALSE;
+GSystemThread zero_thread; /* This is initialized to all zero */
+GMutex g_once_mutex = G_MUTEX_INIT;
+
static GCond g_once_cond = G_COND_INIT;
static GPrivate g_thread_specific_private;
static GRealThread *g_thread_all_threads = NULL;
/**
* g_thread_init:
* @vtable: a function table of type #GThreadFunctions, that provides
- * the entry points to the thread system to be used.
+ * the entry points to the thread system to be used. Since 2.32,
+ * this parameter is ignored and should always be %NULL
*
* If you use GLib from more than one thread, you must initialize the
- * thread system by calling g_thread_init(). Most of the time you will
- * only have to call <literal>g_thread_init (NULL)</literal>.
- *
- * <note><para>Do not call g_thread_init() with a non-%NULL parameter unless
- * you really know what you are doing.</para></note>
+ * thread system by calling g_thread_init().
*
- * <note><para>g_thread_init() must not be called directly or indirectly as a
- * callback from GLib. Also no mutexes may be currently locked while
- * calling g_thread_init().</para></note>
+ * Since version 2.24, calling g_thread_init() multiple times is allowed,
+ * but nothing happens except for the first call.
*
- * <note><para>g_thread_init() changes the way in which #GTimer measures
- * elapsed time. As a consequence, timers that are running while
- * g_thread_init() is called may report unreliable times.</para></note>
+ * Since version 2.32, GLib does not support custom thread implementations
+ * anymore and the @vtable parameter is ignored and you should pass %NULL.
*
- * Calling g_thread_init() multiple times is allowed (since version
- * 2.24), but nothing happens except for the first call. If the
- * argument is non-%NULL on such a call a warning will be printed, but
- * otherwise the argument is ignored.
- *
- * If no thread system is available and @vtable is %NULL or if not all
- * elements of @vtable are non-%NULL, then g_thread_init() will abort.
+ * <note><para>g_thread_init() must not be called directly or indirectly
+ * in a callback from GLib. Also no mutexes may be currently locked while
+ * calling g_thread_init().</para></note>
*
- * <note><para>To use g_thread_init() in your program, you have to link with
- * the libraries that the command <command>pkg-config --libs
+ * <note><para>To use g_thread_init() in your program, you have to link
+ * with the libraries that the command <command>pkg-config --libs
* gthread-2.0</command> outputs. This is not the case for all the
- * other thread related functions of GLib. Those can be used without
+ * other thread-related functions of GLib. Those can be used without
* having to link with the thread libraries.</para></note>
- **/
-
-/* This must be called only once, before any threads are created.
- * It will only be called from g_thread_init() in -lgthread.
*/
+
void
g_thread_init_glib (void)
{
static gboolean already_done;
+ GRealThread* main_thread;
if (already_done)
return;
already_done = TRUE;
- _g_thread_impl_init ();
-
/* We let the main thread (the one that calls g_thread_init) inherit
* the static_private data set before calling g_thread_init
*/
- GRealThread* main_thread = (GRealThread*) g_thread_self ();
+ main_thread = (GRealThread*) g_thread_self ();
/* setup the basic threading system */
g_threads_got_initialized = TRUE;
g_private_init (&g_thread_specific_private, g_thread_cleanup);
g_private_set (&g_thread_specific_private, main_thread);
- G_THREAD_UF (thread_self, (&main_thread->system_thread));
+ g_system_thread_self (&main_thread->system_thread);
/* accomplish log system initialization to enable messaging */
_g_messages_thread_init_nomessage ();
}
-/* The following sections implement: GOnce, GStaticMutex, GStaticRecMutex,
- * GStaticPrivate,
- **/
-
/* GOnce {{{1 ------------------------------------------------------------- */
/**
once->status = G_ONCE_STATUS_PROGRESS;
g_mutex_unlock (&g_once_mutex);
- once->retval = func (arg);
-
- g_mutex_lock (&g_once_mutex);
- once->status = G_ONCE_STATUS_READY;
- g_cond_broadcast (&g_once_cond);
- }
-
- g_mutex_unlock (&g_once_mutex);
-
- return once->retval;
-}
-
-/**
- * g_once_init_enter:
- * @value_location: location of a static initializable variable
- * containing 0.
- * @Returns: %TRUE if the initialization section should be entered,
- * %FALSE and blocks otherwise
- *
- * Function to be called when starting a critical initialization
- * section. The argument @value_location must point to a static
- * 0-initialized variable that will be set to a value other than 0 at
- * the end of the initialization section. In combination with
- * g_once_init_leave() and the unique address @value_location, it can
- * be ensured that an initialization section will be executed only once
- * during a program's life time, and that concurrent threads are
- * blocked until initialization completed. To be used in constructs
- * like this:
- *
- * <informalexample>
- * <programlisting>
- * static gsize initialization_value = 0;
- *
- * if (g_once_init_enter (&initialization_value))
- * {
- * gsize setup_value = 42; /<!-- -->* initialization code here *<!-- -->/
- *
- * g_once_init_leave (&initialization_value, setup_value);
- * }
- *
- * /<!-- -->* use initialization_value here *<!-- -->/
- * </programlisting>
- * </informalexample>
- *
- * Since: 2.14
- **/
-gboolean
-g_once_init_enter_impl (volatile gsize *value_location)
-{
- gboolean need_init = FALSE;
- g_mutex_lock (&g_once_mutex);
- if (g_atomic_pointer_get (value_location) == NULL)
- {
- if (!g_slist_find (g_once_init_list, (void*) value_location))
- {
- need_init = TRUE;
- g_once_init_list = g_slist_prepend (g_once_init_list, (void*) value_location);
- }
- else
- do
- g_cond_wait (&g_once_cond, &g_once_mutex);
- while (g_slist_find (g_once_init_list, (void*) value_location));
- }
- g_mutex_unlock (&g_once_mutex);
- return need_init;
-}
-
-/**
- * g_once_init_leave:
- * @value_location: location of a static initializable variable
- * containing 0.
- * @initialization_value: new non-0 value for *@value_location.
- *
- * Counterpart to g_once_init_enter(). Expects a location of a static
- * 0-initialized initialization variable, and an initialization value
- * other than 0. Sets the variable to the initialization value, and
- * releases concurrent threads blocking in g_once_init_enter() on this
- * initialization variable.
- *
- * Since: 2.14
- **/
-void
-g_once_init_leave (volatile gsize *value_location,
- gsize initialization_value)
-{
- g_return_if_fail (g_atomic_pointer_get (value_location) == NULL);
- g_return_if_fail (initialization_value != 0);
- g_return_if_fail (g_once_init_list != NULL);
-
- g_atomic_pointer_set (value_location, initialization_value);
- g_mutex_lock (&g_once_mutex);
- g_once_init_list = g_slist_remove (g_once_init_list, (void*) value_location);
- g_cond_broadcast (&g_once_cond);
- g_mutex_unlock (&g_once_mutex);
-}
-
-/* GStaticMutex {{{1 ------------------------------------------------------ */
-
-/**
- * GStaticMutex:
- *
- * A #GStaticMutex works like a #GMutex, but it has one significant
- * advantage. It doesn't need to be created at run-time like a #GMutex,
- * but can be defined at compile-time. Here is a shorter, easier and
- * safer version of our <function>give_me_next_number()</function>
- * example:
- *
- * <example>
- * <title>
- * Using <structname>GStaticMutex</structname>
- * to simplify thread-safe programming
- * </title>
- * <programlisting>
- * int
- * give_me_next_number (void)
- * {
- * static int current_number = 0;
- * int ret_val;
- * static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
- *
- * g_static_mutex_lock (&mutex);
- * ret_val = current_number = calc_next_number (current_number);
- * g_static_mutex_unlock (&mutex);
- *
- * return ret_val;
- * }
- * </programlisting>
- * </example>
- *
- * Sometimes you would like to dynamically create a mutex. If you don't
- * want to require prior calling to g_thread_init(), because your code
- * should also be usable in non-threaded programs, you are not able to
- * use g_mutex_new() and thus #GMutex, as that requires a prior call to
- * g_thread_init(). In theses cases you can also use a #GStaticMutex.
- * It must be initialized with g_static_mutex_init() before using it
- * and freed with with g_static_mutex_free() when not needed anymore to
- * free up any allocated resources.
- *
- * Even though #GStaticMutex is not opaque, it should only be used with
- * the following functions, as it is defined differently on different
- * platforms.
- *
- * All of the <function>g_static_mutex_*</function> functions apart
- * from <function>g_static_mutex_get_mutex</function> can also be used
- * even if g_thread_init() has not yet been called. Then they do
- * nothing, apart from <function>g_static_mutex_trylock</function>,
- * which does nothing but returning %TRUE.
- *
- * <note><para>All of the <function>g_static_mutex_*</function>
- * functions are actually macros. Apart from taking their addresses, you
- * can however use them as if they were functions.</para></note>
- **/
-
-/**
- * G_STATIC_MUTEX_INIT:
- *
- * A #GStaticMutex must be initialized with this macro, before it can
- * be used. This macro can used be to initialize a variable, but it
- * cannot be assigned to a variable. In that case you have to use
- * g_static_mutex_init().
- *
- * <informalexample>
- * <programlisting>
- * GStaticMutex my_mutex = G_STATIC_MUTEX_INIT;
- * </programlisting>
- * </informalexample>
- **/
-
-/**
- * g_static_mutex_init:
- * @mutex: a #GStaticMutex to be initialized.
- *
- * Initializes @mutex. Alternatively you can initialize it with
- * #G_STATIC_MUTEX_INIT.
- **/
-void
-g_static_mutex_init (GStaticMutex *mutex)
-{
- static const GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;
-
- g_return_if_fail (mutex);
-
- *mutex = init_mutex;
-}
-
-/* IMPLEMENTATION NOTE:
- *
- * On some platforms a GStaticMutex is actually a normal GMutex stored
- * inside of a structure instead of being allocated dynamically. We can
- * only do this for platforms on which we know, in advance, how to
- * allocate (size) and initialise (value) that memory.
- *
- * On other platforms, a GStaticMutex is nothing more than a pointer to
- * a GMutex. In that case, the first access we make to the static mutex
- * must first allocate the normal GMutex and store it into the pointer.
- *
- * configure.ac writes macros into glibconfig.h to determine if
- * g_static_mutex_get_mutex() accesses the structure in memory directly
- * (on platforms where we are able to do that) or if it ends up here,
- * where we may have to allocate the GMutex before returning it.
- */
-
-/**
- * g_static_mutex_get_mutex:
- * @mutex: a #GStaticMutex.
- * @Returns: the #GMutex corresponding to @mutex.
- *
- * For some operations (like g_cond_wait()) you must have a #GMutex
- * instead of a #GStaticMutex. This function will return the
- * corresponding #GMutex for @mutex.
- **/
-GMutex *
-g_static_mutex_get_mutex_impl (GMutex** mutex)
-{
- GMutex *result;
-
- if (!g_thread_supported ())
- return NULL;
-
- result = g_atomic_pointer_get (mutex);
-
- if (!result)
- {
- g_mutex_lock (&g_once_mutex);
-
- result = *mutex;
- if (!result)
- {
- result = g_mutex_new ();
- g_atomic_pointer_set (mutex, result);
- }
-
- g_mutex_unlock (&g_once_mutex);
- }
-
- return result;
-}
-
-/* IMPLEMENTATION NOTE:
- *
- * g_static_mutex_lock(), g_static_mutex_trylock() and
- * g_static_mutex_unlock() are all preprocessor macros that wrap the
- * corresponding g_mutex_*() function around a call to
- * g_static_mutex_get_mutex().
- */
-
-/**
- * g_static_mutex_lock:
- * @mutex: a #GStaticMutex.
- *
- * Works like g_mutex_lock(), but for a #GStaticMutex.
- **/
-
-/**
- * g_static_mutex_trylock:
- * @mutex: a #GStaticMutex.
- * @Returns: %TRUE, if the #GStaticMutex could be locked.
- *
- * Works like g_mutex_trylock(), but for a #GStaticMutex.
- **/
-
-/**
- * g_static_mutex_unlock:
- * @mutex: a #GStaticMutex.
- *
- * Works like g_mutex_unlock(), but for a #GStaticMutex.
- **/
-
-/**
- * g_static_mutex_free:
- * @mutex: a #GStaticMutex to be freed.
- *
- * Releases all resources allocated to @mutex.
- *
- * You don't have to call this functions for a #GStaticMutex with an
- * unbounded lifetime, i.e. objects declared 'static', but if you have
- * a #GStaticMutex as a member of a structure and the structure is
- * freed, you should also free the #GStaticMutex.
- *
- * <note><para>Calling g_static_mutex_free() on a locked mutex may
- * result in undefined behaviour.</para></note>
- **/
-void
-g_static_mutex_free (GStaticMutex* mutex)
-{
- GMutex **runtime_mutex;
-
- g_return_if_fail (mutex);
-
- /* The runtime_mutex is the first (or only) member of GStaticMutex,
- * see both versions (of glibconfig.h) in configure.ac. Note, that
- * this variable is NULL, if g_thread_init() hasn't been called or
- * if we're using the default thread implementation and it provides
- * static mutexes. */
- runtime_mutex = ((GMutex**)mutex);
-
- if (*runtime_mutex)
- g_mutex_free (*runtime_mutex);
-
- *runtime_mutex = NULL;
-}
-
-/* ------------------------------------------------------------------------ */
-
-/**
- * GStaticRecMutex:
- *
- * A #GStaticRecMutex works like a #GStaticMutex, but it can be locked
- * multiple times by one thread. If you enter it n times, you have to
- * unlock it n times again to let other threads lock it. An exception
- * is the function g_static_rec_mutex_unlock_full(): that allows you to
- * unlock a #GStaticRecMutex completely returning the depth, (i.e. the
- * number of times this mutex was locked). The depth can later be used
- * to restore the state of the #GStaticRecMutex by calling
- * g_static_rec_mutex_lock_full().
- *
- * Even though #GStaticRecMutex is not opaque, it should only be used
- * with the following functions.
- *
- * All of the <function>g_static_rec_mutex_*</function> functions can
- * be used even if g_thread_init() has not been called. Then they do
- * nothing, apart from <function>g_static_rec_mutex_trylock</function>,
- * which does nothing but returning %TRUE.
- **/
-
-/**
- * G_STATIC_REC_MUTEX_INIT:
- *
- * A #GStaticRecMutex must be initialized with this macro before it can
- * be used. This macro can used be to initialize a variable, but it
- * cannot be assigned to a variable. In that case you have to use
- * g_static_rec_mutex_init().
- *
- * <informalexample>
- * <programlisting>
- * GStaticRecMutex my_mutex = G_STATIC_REC_MUTEX_INIT;
- * </programlisting>
- </informalexample>
- **/
-
-/**
- * g_static_rec_mutex_init:
- * @mutex: a #GStaticRecMutex to be initialized.
- *
- * A #GStaticRecMutex must be initialized with this function before it
- * can be used. Alternatively you can initialize it with
- * #G_STATIC_REC_MUTEX_INIT.
- **/
-void
-g_static_rec_mutex_init (GStaticRecMutex *mutex)
-{
- static const GStaticRecMutex init_mutex = G_STATIC_REC_MUTEX_INIT;
-
- g_return_if_fail (mutex);
-
- *mutex = init_mutex;
-}
-
-/**
- * g_static_rec_mutex_lock:
- * @mutex: a #GStaticRecMutex to lock.
- *
- * Locks @mutex. If @mutex is already locked by another thread, the
- * current thread will block until @mutex is unlocked by the other
- * thread. If @mutex is already locked by the calling thread, this
- * functions increases the depth of @mutex and returns immediately.
- **/
-void
-g_static_rec_mutex_lock (GStaticRecMutex* mutex)
-{
- GSystemThread self;
-
- g_return_if_fail (mutex);
-
- if (!g_thread_supported ())
- return;
-
- G_THREAD_UF (thread_self, (&self));
-
- if (g_system_thread_equal (&self, &mutex->owner))
- {
- mutex->depth++;
- return;
- }
- g_static_mutex_lock (&mutex->mutex);
- g_system_thread_assign (mutex->owner, self);
- mutex->depth = 1;
-}
-
-/**
- * g_static_rec_mutex_trylock:
- * @mutex: a #GStaticRecMutex to lock.
- * @Returns: %TRUE, if @mutex could be locked.
- *
- * Tries to lock @mutex. If @mutex is already locked by another thread,
- * it immediately returns %FALSE. Otherwise it locks @mutex and returns
- * %TRUE. If @mutex is already locked by the calling thread, this
- * functions increases the depth of @mutex and immediately returns
- * %TRUE.
- **/
-gboolean
-g_static_rec_mutex_trylock (GStaticRecMutex* mutex)
-{
- GSystemThread self;
-
- g_return_val_if_fail (mutex, FALSE);
-
- if (!g_thread_supported ())
- return TRUE;
-
- G_THREAD_UF (thread_self, (&self));
-
- if (g_system_thread_equal (&self, &mutex->owner))
- {
- mutex->depth++;
- return TRUE;
- }
-
- if (!g_static_mutex_trylock (&mutex->mutex))
- return FALSE;
-
- g_system_thread_assign (mutex->owner, self);
- mutex->depth = 1;
- return TRUE;
-}
-
-/**
- * g_static_rec_mutex_unlock:
- * @mutex: a #GStaticRecMutex to unlock.
- *
- * Unlocks @mutex. Another thread will be allowed to lock @mutex only
- * when it has been unlocked as many times as it had been locked
- * before. If @mutex is completely unlocked and another thread is
- * blocked in a g_static_rec_mutex_lock() call for @mutex, it will be
- * woken and can lock @mutex itself.
- **/
-void
-g_static_rec_mutex_unlock (GStaticRecMutex* mutex)
-{
- g_return_if_fail (mutex);
-
- if (!g_thread_supported ())
- return;
-
- if (mutex->depth > 1)
- {
- mutex->depth--;
- return;
- }
- g_system_thread_assign (mutex->owner, zero_thread);
- g_static_mutex_unlock (&mutex->mutex);
-}
-
-/**
- * g_static_rec_mutex_lock_full:
- * @mutex: a #GStaticRecMutex to lock.
- * @depth: number of times this mutex has to be unlocked to be
- * completely unlocked.
- *
- * Works like calling g_static_rec_mutex_lock() for @mutex @depth times.
- **/
-void
-g_static_rec_mutex_lock_full (GStaticRecMutex *mutex,
- guint depth)
-{
- GSystemThread self;
- g_return_if_fail (mutex);
-
- if (!g_thread_supported ())
- return;
+ once->retval = func (arg);
- if (depth == 0)
- return;
+ g_mutex_lock (&g_once_mutex);
+ once->status = G_ONCE_STATUS_READY;
+ g_cond_broadcast (&g_once_cond);
+ }
- G_THREAD_UF (thread_self, (&self));
+ g_mutex_unlock (&g_once_mutex);
- if (g_system_thread_equal (&self, &mutex->owner))
- {
- mutex->depth += depth;
- return;
- }
- g_static_mutex_lock (&mutex->mutex);
- g_system_thread_assign (mutex->owner, self);
- mutex->depth = depth;
+ return once->retval;
}
/**
- * g_static_rec_mutex_unlock_full:
- * @mutex: a #GStaticRecMutex to completely unlock.
- * @Returns: number of times @mutex has been locked by the current
- * thread.
- *
- * Completely unlocks @mutex. If another thread is blocked in a
- * g_static_rec_mutex_lock() call for @mutex, it will be woken and can
- * lock @mutex itself. This function returns the number of times that
- * @mutex has been locked by the current thread. To restore the state
- * before the call to g_static_rec_mutex_unlock_full() you can call
- * g_static_rec_mutex_lock_full() with the depth returned by this
- * function.
+ * g_once_init_enter:
+ * @value_location: location of a static initializable variable
+ * containing 0.
+ * @Returns: %TRUE if the initialization section should be entered,
+ * %FALSE and blocks otherwise
+ *
+ * Function to be called when starting a critical initialization
+ * section. The argument @value_location must point to a static
+ * 0-initialized variable that will be set to a value other than 0 at
+ * the end of the initialization section. In combination with
+ * g_once_init_leave() and the unique address @value_location, it can
+ * be ensured that an initialization section will be executed only once
+ * during a program's life time, and that concurrent threads are
+ * blocked until initialization completed. To be used in constructs
+ * like this:
+ *
+ * <informalexample>
+ * <programlisting>
+ * static gsize initialization_value = 0;
+ *
+ * if (g_once_init_enter (&initialization_value))
+ * {
+ * gsize setup_value = 42; /<!-- -->* initialization code here *<!-- -->/
+ *
+ * g_once_init_leave (&initialization_value, setup_value);
+ * }
+ *
+ * /<!-- -->* use initialization_value here *<!-- -->/
+ * </programlisting>
+ * </informalexample>
+ *
+ * Since: 2.14
**/
-guint
-g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex)
+gboolean
+g_once_init_enter_impl (volatile gsize *value_location)
{
- guint depth;
-
- g_return_val_if_fail (mutex, 0);
-
- if (!g_thread_supported ())
- return 1;
-
- depth = mutex->depth;
-
- g_system_thread_assign (mutex->owner, zero_thread);
- mutex->depth = 0;
- g_static_mutex_unlock (&mutex->mutex);
-
- return depth;
+ gboolean need_init = FALSE;
+ g_mutex_lock (&g_once_mutex);
+ if (g_atomic_pointer_get (value_location) == NULL)
+ {
+ if (!g_slist_find (g_once_init_list, (void*) value_location))
+ {
+ need_init = TRUE;
+ g_once_init_list = g_slist_prepend (g_once_init_list, (void*) value_location);
+ }
+ else
+ do
+ g_cond_wait (&g_once_cond, &g_once_mutex);
+ while (g_slist_find (g_once_init_list, (void*) value_location));
+ }
+ g_mutex_unlock (&g_once_mutex);
+ return need_init;
}
/**
- * g_static_rec_mutex_free:
- * @mutex: a #GStaticRecMutex to be freed.
+ * g_once_init_leave:
+ * @value_location: location of a static initializable variable
+ * containing 0.
+ * @initialization_value: new non-0 value for *@value_location.
*
- * Releases all resources allocated to a #GStaticRecMutex.
+ * Counterpart to g_once_init_enter(). Expects a location of a static
+ * 0-initialized initialization variable, and an initialization value
+ * other than 0. Sets the variable to the initialization value, and
+ * releases concurrent threads blocking in g_once_init_enter() on this
+ * initialization variable.
*
- * You don't have to call this functions for a #GStaticRecMutex with an
- * unbounded lifetime, i.e. objects declared 'static', but if you have
- * a #GStaticRecMutex as a member of a structure and the structure is
- * freed, you should also free the #GStaticRecMutex.
+ * Since: 2.14
**/
void
-g_static_rec_mutex_free (GStaticRecMutex *mutex)
+g_once_init_leave (volatile gsize *value_location,
+ gsize initialization_value)
{
- g_return_if_fail (mutex);
+ g_return_if_fail (g_atomic_pointer_get (value_location) == NULL);
+ g_return_if_fail (initialization_value != 0);
+ g_return_if_fail (g_once_init_list != NULL);
- g_static_mutex_free (&mutex->mutex);
+ g_atomic_pointer_set (value_location, initialization_value);
+ g_mutex_lock (&g_once_mutex);
+ g_once_init_list = g_slist_remove (g_once_init_list, (void*) value_location);
+ g_cond_broadcast (&g_once_cond);
+ g_mutex_unlock (&g_once_mutex);
}
/* GStaticPrivate {{{1 ---------------------------------------------------- */
+typedef struct _GStaticPrivateNode GStaticPrivateNode;
+struct _GStaticPrivateNode
+{
+ gpointer data;
+ GDestroyNotify destroy;
+};
+
/**
* GStaticPrivate:
*
* Every #GStaticPrivate must be initialized with this macro, before it
* can be used.
*
- * <informalexample>
- * <programlisting>
+ * |[
* GStaticPrivate my_private = G_STATIC_PRIVATE_INIT;
- * </programlisting>
- * </informalexample>
- **/
+ * ]|
+ */
/**
* g_static_private_init:
* Works like g_private_get() only for a #GStaticPrivate.
*
* This function works even if g_thread_init() has not yet been called.
- **/
+ */
gpointer
g_static_private_get (GStaticPrivate *private_key)
{
*
* <note><para>@notify is used quite differently from @destructor in
* g_private_new().</para></note>
- **/
+ */
void
g_static_private_set (GStaticPrivate *private_key,
gpointer data,
* unbounded lifetime, i.e. objects declared 'static', but if you have
* a #GStaticPrivate as a member of a structure and the structure is
* freed, you should also free the #GStaticPrivate.
- **/
+ */
void
g_static_private_free (GStaticPrivate *private_key)
{
}
}
-static void
-g_thread_fail (void)
-{
- g_error ("The thread system is not yet initialized.");
-}
-
-#define G_NSEC_PER_SEC 1000000000
-
-static guint64
-gettime (void)
-{
- return g_get_monotonic_time () * 1000;
-}
-
static gpointer
g_thread_create_proxy (gpointer data)
{
*
* Returns: the new #GThread on success
*/
+GThread *
+g_thread_create (GThreadFunc func,
+ gpointer data,
+ gboolean joinable,
+ GError **error)
+{
+ return g_thread_create_with_stack_size (func, data, joinable, 0, error);
+}
/**
- * g_thread_create_full:
+ * g_thread_create_with_stack_size:
* @func: a function to execute in the new thread.
* @data: an argument to supply to the new thread.
- * @stack_size: a stack size for the new thread.
* @joinable: should this thread be joinable?
- * @bound: should this thread be bound to a system thread?
- * @priority: ignored
+ * @stack_size: a stack size for the new thread.
* @error: return location for error.
* @Returns: the new #GThread on success.
*
*
* If @joinable is %TRUE, you can wait for this threads termination
* calling g_thread_join(). Otherwise the thread will just disappear
- * when it terminates. If @bound is %TRUE, this thread will be
- * scheduled in the system scope, otherwise the implementation is free
- * to do scheduling in the process scope. The first variant is more
- * expensive resource-wise, but generally faster. On some systems (e.g.
- * Linux) all threads are bound.
+ * when it terminates.
*
* The new thread executes the function @func with the argument @data.
* If the thread was created successfully, it is returned.
* @error can be %NULL to ignore errors, or non-%NULL to report errors.
* The error is set, if and only if the function returns %NULL.
*
- * <note><para>Only use g_thread_create_full() if you really can't use
- * g_thread_create() instead. g_thread_create() does not take
- * @stack_size, @bound, and @priority as arguments, as they should only
- * be used in cases in which it is unavoidable.</para></note>
+ * <note><para>
+ * Only use g_thread_create_with_stack_size() if you really can't use
+ * g_thread_create() instead. g_thread_create() does not take
+ * @stack_size, as it should only be used in cases in which it is
+ * unavoidable.
+ * </para></note>
**/
GThread*
-g_thread_create_full (GThreadFunc func,
- gpointer data,
- gulong stack_size,
- gboolean joinable,
- gboolean bound,
- GThreadPriority priority,
- GError **error)
+g_thread_create_with_stack_size (GThreadFunc func,
+ gpointer data,
+ gboolean joinable,
+ gsize stack_size,
+ GError **error)
{
GRealThread* result;
GError *local_error = NULL;
result->thread.data = data;
result->private_data = NULL;
G_LOCK (g_thread);
- G_THREAD_UF (thread_create, (g_thread_create_proxy, result,
- stack_size, joinable, bound, 0,
- &result->system_thread, &local_error));
+ g_system_thread_create (g_thread_create_proxy, result,
+ stack_size, joinable,
+ &result->system_thread, &local_error);
if (!local_error)
{
result->next = g_thread_all_threads;
g_return_val_if_fail (thread->joinable, NULL);
g_return_val_if_fail (!g_system_thread_equal (&real->system_thread, &zero_thread), NULL);
- G_THREAD_UF (thread_join, (&real->system_thread));
+ g_system_thread_join (&real->system_thread);
retval = real->retval;
g_system_thread_assign (real->system_thread, zero_thread);
/* the thread structure for non-joinable threads is freed upon
- thread end. We free the memory here. This will leave a loose end,
- if a joinable thread is not joined. */
-
+ * thread end. We free the memory here. This will leave a loose end,
+ * if a joinable thread is not joined.
+ */
g_free (thread);
return retval;
}
/**
- * g_thread_set_priority:
- * @thread: a #GThread.
- * @priority: ignored
- *
- * This function does nothing.
- *
- * Deprecated:2.32: Thread priorities no longer have any effect.
- **/
-void
-g_thread_set_priority (GThread *thread,
- GThreadPriority priority)
-{
-}
-
-/**
* g_thread_self:
* @Returns: the current thread.
*
thread->thread.data = NULL;
thread->private_data = NULL;
- G_THREAD_UF (thread_self, (&thread->system_thread));
+ g_system_thread_self (&thread->system_thread);
g_private_set (&g_thread_specific_private, thread);
return (GThread*)thread;
}
-/* GStaticRWLock {{{1 ----------------------------------------------------- */
-
-/**
- * GStaticRWLock:
- *
- * The #GStaticRWLock struct represents a read-write lock. A read-write
- * lock can be used for protecting data that some portions of code only
- * read from, while others also write. In such situations it is
- * desirable that several readers can read at once, whereas of course
- * only one writer may write at a time. Take a look at the following
- * example:
- *
- * <example>
- * <title>An array with access functions</title>
- * <programlisting>
- * GStaticRWLock rwlock = G_STATIC_RW_LOCK_INIT;
- * GPtrArray *array;
- *
- * gpointer
- * my_array_get (guint index)
- * {
- * gpointer retval = NULL;
- *
- * if (!array)
- * return NULL;
- *
- * g_static_rw_lock_reader_lock (&rwlock);
- * if (index < array->len)
- * retval = g_ptr_array_index (array, index);
- * g_static_rw_lock_reader_unlock (&rwlock);
- *
- * return retval;
- * }
- *
- * void
- * my_array_set (guint index, gpointer data)
- * {
- * g_static_rw_lock_writer_lock (&rwlock);
- *
- * if (!array)
- * array = g_ptr_array_new (<!-- -->);
- *
- * if (index >= array->len)
- * g_ptr_array_set_size (array, index+1);
- * g_ptr_array_index (array, index) = data;
- *
- * g_static_rw_lock_writer_unlock (&rwlock);
- * }
- * </programlisting>
- * </example>
- *
- * This example shows an array which can be accessed by many readers
- * (the <function>my_array_get()</function> function) simultaneously,
- * whereas the writers (the <function>my_array_set()</function>
- * function) will only be allowed once at a time and only if no readers
- * currently access the array. This is because of the potentially
- * dangerous resizing of the array. Using these functions is fully
- * multi-thread safe now.
- *
- * Most of the time, writers should have precedence over readers. That
- * means, for this implementation, that as soon as a writer wants to
- * lock the data, no other reader is allowed to lock the data, whereas,
- * of course, the readers that already have locked the data are allowed
- * to finish their operation. As soon as the last reader unlocks the
- * data, the writer will lock it.
- *
- * Even though #GStaticRWLock is not opaque, it should only be used
- * with the following functions.
- *
- * All of the <function>g_static_rw_lock_*</function> functions can be
- * used even if g_thread_init() has not been called. Then they do
- * nothing, apart from <function>g_static_rw_lock_*_trylock</function>,
- * which does nothing but returning %TRUE.
- *
- * <note><para>A read-write lock has a higher overhead than a mutex. For
- * example, both g_static_rw_lock_reader_lock() and
- * g_static_rw_lock_reader_unlock() have to lock and unlock a
- * #GStaticMutex, so it takes at least twice the time to lock and unlock
- * a #GStaticRWLock that it does to lock and unlock a #GStaticMutex. So
- * only data structures that are accessed by multiple readers, and which
- * keep the lock for a considerable time justify a #GStaticRWLock. The
- * above example most probably would fare better with a
- * #GStaticMutex.</para></note>
- **/
-
-/**
- * G_STATIC_RW_LOCK_INIT:
- *
- * A #GStaticRWLock must be initialized with this macro before it can
- * be used. This macro can used be to initialize a variable, but it
- * cannot be assigned to a variable. In that case you have to use
- * g_static_rw_lock_init().
- *
- * <informalexample>
- * <programlisting>
- * GStaticRWLock my_lock = G_STATIC_RW_LOCK_INIT;
- * </programlisting>
- * </informalexample>
- **/
-
-/**
- * g_static_rw_lock_init:
- * @lock: a #GStaticRWLock to be initialized.
- *
- * A #GStaticRWLock must be initialized with this function before it
- * can be used. Alternatively you can initialize it with
- * #G_STATIC_RW_LOCK_INIT.
- **/
-void
-g_static_rw_lock_init (GStaticRWLock* lock)
-{
- static const GStaticRWLock init_lock = G_STATIC_RW_LOCK_INIT;
-
- g_return_if_fail (lock);
-
- *lock = init_lock;
-}
-
-inline static void
-g_static_rw_lock_wait (GCond** cond, GStaticMutex* mutex)
-{
- if (!*cond)
- *cond = g_cond_new ();
- g_cond_wait (*cond, g_static_mutex_get_mutex (mutex));
-}
-
-inline static void
-g_static_rw_lock_signal (GStaticRWLock* lock)
-{
- if (lock->want_to_write && lock->write_cond)
- g_cond_signal (lock->write_cond);
- else if (lock->want_to_read && lock->read_cond)
- g_cond_broadcast (lock->read_cond);
-}
-
-/**
- * g_static_rw_lock_reader_lock:
- * @lock: a #GStaticRWLock to lock for reading.
- *
- * Locks @lock for reading. There may be unlimited concurrent locks for
- * reading of a #GStaticRWLock at the same time. If @lock is already
- * locked for writing by another thread or if another thread is already
- * waiting to lock @lock for writing, this function will block until
- * @lock is unlocked by the other writing thread and no other writing
- * threads want to lock @lock. This lock has to be unlocked by
- * g_static_rw_lock_reader_unlock().
- *
- * #GStaticRWLock is not recursive. It might seem to be possible to
- * recursively lock for reading, but that can result in a deadlock, due
- * to writer preference.
- **/
-void
-g_static_rw_lock_reader_lock (GStaticRWLock* lock)
-{
- g_return_if_fail (lock);
-
- if (!g_threads_got_initialized)
- return;
-
- g_static_mutex_lock (&lock->mutex);
- lock->want_to_read++;
- while (lock->have_writer || lock->want_to_write)
- g_static_rw_lock_wait (&lock->read_cond, &lock->mutex);
- lock->want_to_read--;
- lock->read_counter++;
- g_static_mutex_unlock (&lock->mutex);
-}
-
-/**
- * g_static_rw_lock_reader_trylock:
- * @lock: a #GStaticRWLock to lock for reading.
- * @Returns: %TRUE, if @lock could be locked for reading.
- *
- * Tries to lock @lock for reading. If @lock is already locked for
- * writing by another thread or if another thread is already waiting to
- * lock @lock for writing, immediately returns %FALSE. Otherwise locks
- * @lock for reading and returns %TRUE. This lock has to be unlocked by
- * g_static_rw_lock_reader_unlock().
- **/
-gboolean
-g_static_rw_lock_reader_trylock (GStaticRWLock* lock)
-{
- gboolean ret_val = FALSE;
-
- g_return_val_if_fail (lock, FALSE);
-
- if (!g_threads_got_initialized)
- return TRUE;
-
- g_static_mutex_lock (&lock->mutex);
- if (!lock->have_writer && !lock->want_to_write)
- {
- lock->read_counter++;
- ret_val = TRUE;
- }
- g_static_mutex_unlock (&lock->mutex);
- return ret_val;
-}
-
-/**
- * g_static_rw_lock_reader_unlock:
- * @lock: a #GStaticRWLock to unlock after reading.
- *
- * Unlocks @lock. If a thread waits to lock @lock for writing and all
- * locks for reading have been unlocked, the waiting thread is woken up
- * and can lock @lock for writing.
- **/
-void
-g_static_rw_lock_reader_unlock (GStaticRWLock* lock)
-{
- g_return_if_fail (lock);
-
- if (!g_threads_got_initialized)
- return;
-
- g_static_mutex_lock (&lock->mutex);
- lock->read_counter--;
- if (lock->read_counter == 0)
- g_static_rw_lock_signal (lock);
- g_static_mutex_unlock (&lock->mutex);
-}
-
-/**
- * g_static_rw_lock_writer_lock:
- * @lock: a #GStaticRWLock to lock for writing.
- *
- * Locks @lock for writing. If @lock is already locked for writing or
- * reading by other threads, this function will block until @lock is
- * completely unlocked and then lock @lock for writing. While this
- * functions waits to lock @lock, no other thread can lock @lock for
- * reading. When @lock is locked for writing, no other thread can lock
- * @lock (neither for reading nor writing). This lock has to be
- * unlocked by g_static_rw_lock_writer_unlock().
- **/
-void
-g_static_rw_lock_writer_lock (GStaticRWLock* lock)
-{
- g_return_if_fail (lock);
-
- if (!g_threads_got_initialized)
- return;
-
- g_static_mutex_lock (&lock->mutex);
- lock->want_to_write++;
- while (lock->have_writer || lock->read_counter)
- g_static_rw_lock_wait (&lock->write_cond, &lock->mutex);
- lock->want_to_write--;
- lock->have_writer = TRUE;
- g_static_mutex_unlock (&lock->mutex);
-}
-
-/**
- * g_static_rw_lock_writer_trylock:
- * @lock: a #GStaticRWLock to lock for writing.
- * @Returns: %TRUE, if @lock could be locked for writing.
- *
- * Tries to lock @lock for writing. If @lock is already locked (for
- * either reading or writing) by another thread, it immediately returns
- * %FALSE. Otherwise it locks @lock for writing and returns %TRUE. This
- * lock has to be unlocked by g_static_rw_lock_writer_unlock().
- **/
-gboolean
-g_static_rw_lock_writer_trylock (GStaticRWLock* lock)
-{
- gboolean ret_val = FALSE;
-
- g_return_val_if_fail (lock, FALSE);
-
- if (!g_threads_got_initialized)
- return TRUE;
-
- g_static_mutex_lock (&lock->mutex);
- if (!lock->have_writer && !lock->read_counter)
- {
- lock->have_writer = TRUE;
- ret_val = TRUE;
- }
- g_static_mutex_unlock (&lock->mutex);
- return ret_val;
-}
-
-/**
- * g_static_rw_lock_writer_unlock:
- * @lock: a #GStaticRWLock to unlock after writing.
- *
- * Unlocks @lock. If a thread is waiting to lock @lock for writing and
- * all locks for reading have been unlocked, the waiting thread is
- * woken up and can lock @lock for writing. If no thread is waiting to
- * lock @lock for writing, and some thread or threads are waiting to
- * lock @lock for reading, the waiting threads are woken up and can
- * lock @lock for reading.
- **/
-void
-g_static_rw_lock_writer_unlock (GStaticRWLock* lock)
-{
- g_return_if_fail (lock);
-
- if (!g_threads_got_initialized)
- return;
-
- g_static_mutex_lock (&lock->mutex);
- lock->have_writer = FALSE;
- g_static_rw_lock_signal (lock);
- g_static_mutex_unlock (&lock->mutex);
-}
-
-/**
- * g_static_rw_lock_free:
- * @lock: a #GStaticRWLock to be freed.
- *
- * Releases all resources allocated to @lock.
- *
- * You don't have to call this functions for a #GStaticRWLock with an
- * unbounded lifetime, i.e. objects declared 'static', but if you have
- * a #GStaticRWLock as a member of a structure, and the structure is
- * freed, you should also free the #GStaticRWLock.
- **/
-void
-g_static_rw_lock_free (GStaticRWLock* lock)
-{
- g_return_if_fail (lock);
-
- if (lock->read_cond)
- {
- g_cond_free (lock->read_cond);
- lock->read_cond = NULL;
- }
- if (lock->write_cond)
- {
- g_cond_free (lock->write_cond);
- lock->write_cond = NULL;
- }
- g_static_mutex_free (&lock->mutex);
-}
-
/* Unsorted {{{1 ---------------------------------------------------------- */
/**
/**
* g_mutex_new:
*
- * Creates a new #GMutex.
+ * Allocated and initializes a new #GMutex.
*
* Returns: a newly allocated #GMutex. Use g_mutex_free() to free
*/
*
* Destroys a @mutex that has been created with g_mutex_new().
*
- * <note>Calling g_mutex_free() on a locked mutex may result
- * in undefined behaviour.</note>
+ * Calling g_mutex_free() on a locked mutex may result
+ * in undefined behaviour.
*/
void
g_mutex_free (GMutex *mutex)
/**
* g_cond_new:
*
- * Creates a new #GCond.
+ * Allocates and initializes a new #GCond.
*
* Returns: a newly allocated #GCond. Free with g_cond_free()
*/
return key;
}
+
+/* vim: set foldmethod=marker: */
projects / platform / upstream / glib.git / blobdiff