Display the source code in core/thread.d from which this page was generated on github.

If you spot a problem with this page, click here to create a Bugzilla issue.

Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone.

Module `core.thread`

The thread module provides support for thread creation and management.

Functions

Name	Description
`_beginthreadex(, , , , , )`
`createLowLevelThread(dg, stacksize, cbDllUnload)`	Create a thread not under control of the runtime, i.e. TLS module constructors are not run and the GC does not suspend it during a collection
`fiber_switchContext(oldp, newp)`
`fiber_trampoline()`
`findLowLevelThread(tid)`	Check whether a thread was created by `createLowLevelThread`
`GetCurrentThreadHandle()`
`joinLowLevelThread(tid)`	Wait for a thread created with `createLowLevelThread` to terminate
`ll_countLowLevelThreadsWithDLLUnloadCallback()`
`ll_dllHasExternalReferences()`
`ll_getDLLRefCount()`
`ll_startDLLUnloadThread()`
`monitorDLLRefCnt()`
`THR_IN_CRITICAL(p)`
`thread_attachByAddr(addr)`	Registers the calling thread for use with the D Runtime. If this routine is called for a thread which is already registered, no action is performed.
`thread_attachByAddrB(addr, bstack)`	Registers the calling thread for use with the D Runtime. If this routine is called for a thread which is already registered, no action is performed.
`thread_attachThis()`	Registers the calling thread for use with the D Runtime. If this routine is called for a thread which is already registered, no action is performed.
`thread_detachByAddr(addr)`	Deregisters the given thread from use with the runtime. If this routine is called for a thread which is not registered, the result is undefined.
`thread_detachInstance(t)`	Deregisters the given thread from use with the runtime. If this routine is called for a thread which is not registered, the result is undefined.
`thread_detachThis()`	Deregisters the calling thread from use with the runtime. If this routine is called for a thread which is not registered, the result is undefined.
`thread_enterCriticalRegion()`	Signals that the code following this call is a critical region. Any code in this region must finish running before the calling thread can be suspended by a call to thread_suspendAll.
`thread_entryPoint(arg)`
`thread_exitCriticalRegion()`	Signals that the calling thread is no longer in a critical region. Following a call to this function, the thread can once again be suspended.
`thread_findByAddr(addr)`	Search the list of all threads for a thread with the given thread identifier.
`thread_inCriticalRegion()`	Returns true if the current thread is in a critical region; otherwise, false.
`thread_init()`	Initializes the thread module. This function must be called by the garbage collector on startup and before any other thread routines are called.
`thread_isMainThread()`
`thread_joinAll()`	Joins all non-daemon threads that are currently running. This is done by performing successive scans through the thread list until a scan consists of only daemon threads.
`thread_processGCMarks(isMarked)`	This routine allows the runtime to process any special per-thread handling for the GC. This is needed for taking into account any memory that is referenced by non-scanned pointers but is about to be freed. That currently means the array append cache.
`thread_resumeAll()`	Resume all threads but the calling thread for "stop the world" garbage collection runs. This function must be called once for each preceding call to thread_suspendAll before the threads are actually resumed.
`thread_scanAll(scan)`	The main entry point for garbage collection. The supplied delegate will be passed ranges representing both stack and register values.
`thread_scanAllType(scan)`	The main entry point for garbage collection. The supplied delegate will be passed ranges representing both stack and register values.
`thread_setGCSignals(suspendSignalNo, resumeSignalNo)`	Instruct the thread module, when initialized, to use a different set of signals besides SIGUSR1 and SIGUSR2 for suspension and resumption of threads. This function should be called at most once, prior to thread_init(). This function is Posix-only.
`thread_setThis(t)`	Sets the current thread to a specific reference. Only to be used when dealing with externally-created threads (in e.g. C code). The primary use of this function is when Thread.getThis() must return a sensible value in, for example, TLS destructors. In other words, don't touch this unless you know what you're doing.
`thread_stackBottom()`	Returns the stack bottom of the currently active stack within the calling thread.
`thread_stackTop()`	Returns the stack top of the currently active stack within the calling thread.
`thread_suspendAll()`	Suspend all threads but the calling thread for "stop the world" garbage collection runs. This function may be called multiple times, and must be followed by a matching number of calls to thread_resumeAll before processing is resumed.
`thread_term()`	Terminates the thread module. No other thread routine may be called afterwards.

Classes

Name	Description
`Fiber`	This class provides a cooperative concurrency mechanism integrated with the threading and garbage collection functionality. Calling a fiber may be considered a blocking operation that returns when the fiber yields (via Fiber.yield()). Execution occurs within the context of the calling thread so synchronization is not necessary to guarantee memory visibility so long as the same thread calls the fiber each time. Please note that there is no requirement that a fiber be bound to one specific thread. Rather, fibers may be freely passed between threads so long as they are not currently executing. Like threads, a new fiber thread may be created using either derivation or composition, as in the following example.
`Thread`	This class encapsulates all threading functionality for the D programming language. As thread manipulation is a required facility for garbage collection, all user threads should derive from this class, and instances of this class should never be explicitly deleted. A new thread may be created using either derivation or composition, as in the following example.
`ThreadError`	Base class for thread errors to be used for function inside GC when allocations are unavailable.
`ThreadException`	Base class for thread exceptions.
`ThreadGroup`	This class is intended to simplify certain common programming techniques.

Enums

Name	Description
`IsMarked`	Indicates whether an address has been marked by the GC.
`ScanType`	Indicates the kind of scan being performed by `thread_scanAllType`.

Global variables

Name	Type	Description
`ll_dllModule`	`HMODULE`
`ll_dllMonitorThread`	`ThreadID`
`msvcUsesUCRT`	`ubyte`
`thread_DLLProcessDetaching`	`bool`

Aliases

Name	Type	Description
`btex_fptr`	`extern(Windows) uint function(void*)`
`getpid`		Returns the process ID of the calling process, which is guaranteed to be unique on the system. This call is always successful.
`IsMarkedDg`	`int delegate(void*)`	The isMarked callback function.
`ScanAllThreadsFn`	`void delegate(void, void)`	The scanning function.
`ScanAllThreadsTypeFn`	`void delegate(ScanType, void, void)`	The scanning function.
`ThreadID`	`ulong`	Represents the ID of a thread, as returned by `Thread.id`. The exact type varies from platform to platform.

Authors

Sean Kelly, Walter Bright, Alex Rønne Petersen, Martin Nowak

License

Distributed under the Boost Software License 1.0. (See accompanying file LICENSE)