Next: Semaphores Up: Threads Previous: Threads

## Thread Utilities

`(current-thread)` returns the thread descriptor for the currently executing thread.

`(thread? v)` returns `#t` if v is a thread descriptor, `#f` otherwise.

`(sleep [x])` causes the current thread to sleep for at least x seconds, where x is a non-negative real number. The x argument defaults to 0 (allowing other threads to execute when operating system threads are not used). The value of x can be non-integral to request a sleep duration to any precision, but the precision of the actual sleep time is unspecified.

`(thread-running? thread)` returns `#t` if thread has not terminated, `#f` otherwise.

`(thread-wait thread)` blocks execution of the current thread until thread has terminated. Note that `(thread-wait (current-thread))` deadlocks the current thread, but a break can end the deadlock (if breaking is enabled; see section 8.6).

`(kill-thread thread)` terminates the specified thread immediately. Terminating the main thread exits the application. If thread is already not running, `kill-thread` does nothing. Otherwise, if the current custodian (see section 9.5) does not manage thread (and none of its subordinates manages thread), the `exn:misc` exception is raised.

All of the MzScheme (and MrEd) primitives are kill-safe; that is, killing a thread never interferes with the application of primitives in other threads. For example, if a thread is killed while extracting a character from an input port, the character is either completely consumed or not consumed, and other threads can safely use the port.

`(break-thread thread)` registers a break with the specified thread. If breaking is disabled in thread, the break will be ignored until breaks are re-enabled (see section 8.6).

`(call-in-nested-thread thunk [custodian])` creates a nested thread managed by custodian to execute thunk. The current thread blocks until thunk returns, and the result of the `call-in-nested-thread` call is the result returned by thunk. The default value of custodian is the current custodian.

The nested thread's exception handler is initialized to a procedure that jumps to the beginning of the thread and transfers the exception to the original thread. The handler thus terminates the nested thread and re-raises the exception in the original thread.

If the thread created by `call-in-nested-thread` dies before thunk returns, the `exn:thread` exception is raised in the original thread. If the original thread is killed before thunk returns, a break is queued for the nested thread.

If a break is queued for the original thread (with `break-thread`) while the nested thread is running, the break is redirected to the nested thread. If a break is already queued on the original thread when the nested thread is created, the break is moved to the nested thread. If a break remains queued on the nested thread when it completes, the break is moved to the original thread.

Next: Semaphores Up: Threads Previous: Threads