Package ch.bailu.gtk.glib

Class Thread

java.lang.Object

ch.bailu.gtk.type.Type

ch.bailu.gtk.type.Pointer

ch.bailu.gtk.type.Record

ch.bailu.gtk.glib.Thread

All Implemented Interfaces:

PointerInterface

public class Thread
extends Record

The #GThread struct represents a running thread. This struct
is returned by g_thread_new() or g_thread_try_new(). You can
obtain the #GThread struct representing the current thread by
calling g_thread_self().

GThread is refcounted, see g_thread_ref() and g_thread_unref().
The thread represented by it holds a reference while it is running,
and g_thread_join() consumes the reference that it is given, so
it is normally not necessary to manage GThread references
explicitly.

The structure is opaque -- none of its fields may be directly
accessed.

https://docs.gtk.org/glib/struct.Thread.html

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static interface	Thread.OnThreadFunc

Field Summary

Fields inherited from class ch.bailu.gtk.type.Pointer

NULL

Constructor Summary

Constructors

Constructor	Description
Thread(PointerContainer pointer)
Thread(Str name, Thread.OnThreadFunc func, Pointer data)	This function creates a new thread.
Thread(String name, Thread.OnThreadFunc func, Pointer data)	This function creates a new thread.

Method Summary

Modifier and Type	Method	Description
static int	errorQuark()
static void	exit(Pointer retval)	Terminates the current thread.
static ClassHandler	getClassHandler()
static int	getInstanceSize()
static long	getParentTypeID()
static TypeSystem.TypeSize	getParentTypeSize()
static long	getTypeID()
static TypeSystem.TypeSize	getTypeSize()
Pointer	join()	Waits until @thread finishes, i.e. the function @func, as given to g_thread_new(), returns or g_thread_exit() is called.
Thread	ref()	Increase the reference count on @thread.
static Thread	self()	This function returns the #GThread corresponding to the current thread.
static Thread	tryNewThread(Str name, Thread.OnThreadFunc func, Pointer data)	This function is the same as g_thread_new() except that it allows for the possibility of failure.
static Thread	tryNewThread(String name, Thread.OnThreadFunc func, Pointer data)	This function is the same as g_thread_new() except that it allows for the possibility of failure.
void	unref()	Decrease the reference count on @thread, possibly freeing all resources associated with it.
static void	yield()	Causes the calling thread to voluntarily relinquish the CPU, so that other threads can run.

Methods inherited from class ch.bailu.gtk.type.Record

destroy

Methods inherited from class ch.bailu.gtk.type.Pointer

asCPointer, cast, connectSignal, disconnectSignals, disconnectSignals, equals, hashCode, throwIfNull, throwNullPointerException, toString, unregisterCallbacks, unregisterCallbacks

Methods inherited from class ch.bailu.gtk.type.Type

asCPointer, asCPointer, asCPointerNotNull, asJnaPointer, asJnaPointer, asPointer, asPointer, cast, cast, throwIfNull

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface ch.bailu.gtk.type.PointerInterface

asCPointerNotNull, asJnaPointer, asPointer, isNotNull, isNull

Constructor Details

Thread

public Thread(PointerContainer pointer)

Thread

public Thread(@Nullable
 Str name,
 Thread.OnThreadFunc func,
 @Nullable
 Pointer data)

This function creates a new thread. The new thread starts by invoking
@func with the argument data. The thread will run until @func returns
or until g_thread_exit() is called from the new thread. The return value
of @func becomes the return value of the thread, which can be obtained
with g_thread_join().

The @name can be useful for discriminating threads in a debugger.
It is not used for other purposes and does not have to be unique.
Some systems restrict the length of @name to 16 bytes.

If the thread can not be created the program aborts. See
g_thread_try_new() if you want to attempt to deal with failures.

If you are using threads to offload (potentially many) short-lived tasks,
#GThreadPool may be more appropriate than manually spawning and tracking
multiple #GThreads.

To free the struct returned by this function, use g_thread_unref().
Note that g_thread_join() implicitly unrefs the #GThread as well.

New threads by default inherit their scheduler policy (POSIX) or thread
priority (Windows) of the thread creating the new thread.

This behaviour changed in GLib 2.64: before threads on Windows were not
inheriting the thread priority but were spawned with the default priority.
Starting with GLib 2.64 the behaviour is now consistent between Windows and
POSIX and all threads inherit their parent thread's priority.

Parameters:

name - an (optional) name for the new thread

func - a function to execute in the new thread

data - an argument to supply to the new thread

Thread

public Thread(String name,
 Thread.OnThreadFunc func,
 @Nullable
 Pointer data)

This function creates a new thread. The new thread starts by invoking
@func with the argument data. The thread will run until @func returns
or until g_thread_exit() is called from the new thread. The return value
of @func becomes the return value of the thread, which can be obtained
with g_thread_join().

The @name can be useful for discriminating threads in a debugger.
It is not used for other purposes and does not have to be unique.
Some systems restrict the length of @name to 16 bytes.

If the thread can not be created the program aborts. See
g_thread_try_new() if you want to attempt to deal with failures.

If you are using threads to offload (potentially many) short-lived tasks,
#GThreadPool may be more appropriate than manually spawning and tracking
multiple #GThreads.

To free the struct returned by this function, use g_thread_unref().
Note that g_thread_join() implicitly unrefs the #GThread as well.

New threads by default inherit their scheduler policy (POSIX) or thread
priority (Windows) of the thread creating the new thread.

This behaviour changed in GLib 2.64: before threads on Windows were not
inheriting the thread priority but were spawned with the default priority.
Starting with GLib 2.64 the behaviour is now consistent between Windows and
POSIX and all threads inherit their parent thread's priority.

Parameters:

name - an (optional) name for the new thread

func - a function to execute in the new thread

data - an argument to supply to the new thread

Method Details

getClassHandler

public static ClassHandler getClassHandler()

tryNewThread

public static Thread tryNewThread(@Nullable
 Str name,
 Thread.OnThreadFunc func,
 @Nullable
 Pointer data)
                           throws AllocationError

This function is the same as g_thread_new() except that
it allows for the possibility of failure.

If a thread can not be created (due to resource limits),
@error is set and %NULL is returned.

Parameters:

name - an (optional) name for the new thread

func - a function to execute in the new thread

data - an argument to supply to the new thread

Returns:

the new #GThread, or %NULL if an error occurred

Throws:

AllocationError

tryNewThread

public static Thread tryNewThread(String name,
 Thread.OnThreadFunc func,
 @Nullable
 Pointer data)
                           throws AllocationError

This function is the same as g_thread_new() except that
it allows for the possibility of failure.

If a thread can not be created (due to resource limits),
@error is set and %NULL is returned.

Parameters:

name - an (optional) name for the new thread

func - a function to execute in the new thread

data - an argument to supply to the new thread

Returns:

the new #GThread, or %NULL if an error occurred

Throws:

AllocationError

join

public Pointer join()

Waits until @thread finishes, i.e. the function @func, as
given to g_thread_new(), returns or g_thread_exit() is called.
If @thread has already terminated, then g_thread_join()
returns immediately.

Any thread can wait for any other thread by calling g_thread_join(),
not just its 'creator'. Calling g_thread_join() from multiple threads
for the same @thread leads to undefined behaviour.

The value returned by @func or given to g_thread_exit() is
returned by this function.

g_thread_join() consumes the reference to the passed-in @thread.
This will usually cause the #GThread struct and associated resources
to be freed. Use g_thread_ref() to obtain an extra reference if you
want to keep the GThread alive beyond the g_thread_join() call.

Returns:

the return value of the thread

ref

public Thread ref()

Increase the reference count on @thread.

Returns:

a new reference to @thread

unref

public void unref()

Decrease the reference count on @thread, possibly freeing all
resources associated with it.

Note that each thread holds a reference to its #GThread while
it is running, so it is safe to drop your own reference to it
if you don't need it anymore.

errorQuark

public static int errorQuark()

Returns:

exit

public static void exit(@Nullable
 Pointer retval)

Terminates the current thread.

If another thread is waiting for us using g_thread_join() then the
waiting thread will be woken up and get @retval as the return value
of g_thread_join().

Calling g_thread_exit() with a parameter @retval is equivalent to
returning @retval from the function @func, as given to g_thread_new().

You must only call g_thread_exit() from a thread that you created
yourself with g_thread_new() or related APIs. You must not call
this function from a thread created with another threading library
or or from within a #GThreadPool.

Parameters:

retval - the return value of this thread

self

public static Thread self()

This function returns the #GThread corresponding to the
current thread. Note that this function does not increase
the reference count of the returned struct.

This function will return a #GThread even for threads that
were not created by GLib (i.e. those created by other threading
APIs). This may be useful for thread identification purposes
(i.e. comparisons) but you must not use GLib functions (such
as g_thread_join()) on these threads.

Returns:

the #GThread representing the current thread

yield

public static void yield()

Causes the calling thread to voluntarily relinquish the CPU, so
that other threads can run.

This function is often used as a method to make busy wait less evil.

getTypeID

public static long getTypeID()

getParentTypeID

public static long getParentTypeID()

getTypeSize

public static TypeSystem.TypeSize getTypeSize()

getParentTypeSize

public static TypeSystem.TypeSize getParentTypeSize()

getInstanceSize

public static int getInstanceSize()