SWI-Prolog 9.2.6 Reference Manual: Section 10.2

## 10.2 Monitoring threads

Normal multithreaded applications should not need the predicates from this section because almost any usage of these predicates is unsafe. For example checking the existence of a thread before signalling it is of no use as it may vanish between the two calls. Catching exceptions using catch/3 is the only safe way to deal with thread-existence errors.

These predicates are provided for diagnosis and monitoring tasks. See also section 10.5, describing more high-level primitives.

is_thread(@Term)
  True if Term is a handle to an existing thread.
thread_property(?Id, ?Property)
  True if thread Id has Property. Either or both arguments may be unbound, enumerating all relations on backtracking. Calling thread_property/2 does not influence any thread. See also thread_join/2. For threads that have an alias name, this name is returned in Id instead of the opaque thread identifier. Defined properties are:
  alias(Alias)
    Alias is the alias name of thread Id.
  detached(Boolean)
    Current detached status of the thread.
  id(Integer)
    Integer identifier for the thread. Can be used as argument to the thread predicates, but applications must be aware that these references are reused.
  status(Status)
    Current status of the thread. Status is one of:
    running
      The thread is running. This is the initial status of a thread. Please note that threads waiting for something are considered running too.
    suspended
      Only if the thread is an engine (see section 11). Indicates that the engine is currently not associated with an OS thread.
    false
      The Goal of the thread has been completed and failed.
    true
      The Goal of the thread has been completed and succeeded.
    exited(Term)
      The Goal of the thread has been terminated using thread_exit/1 with Term as argument. If the underlying native thread has exited (using pthread_exit()) Term is unbound.
    exception(Term)
      The Goal of the thread has been terminated due to an uncaught exception (see throw/1 and catch/3).
  engine(Boolean)
    If the thread is an engine (see chapter 11), Boolean is `true`. Otherwise the property is not present.
  thread(ThreadId)
    If the thread is an engine that is currently attached to a thread, ThreadId is the thread that executes the engine.
  size(Bytes)
    The amount of memory associated with this thread. This includes the thread structure, its stacks, its default message queue, its clauses in its thread local dynamic predicates (see thread_local/1) and memory used for representing thread-local answer tries (see section 7).
  system_thread_id(Integer)
    Thread identifier used by the operating system for the calling thread. Not available on all OSes. This is the same as the Prolog flag system_thread_id for the calling thread. Access to the system thread identifier can, on some systems, be used to gain additional control over or information about Prolog threads.

  See also thread_statistics/3 to obtain resource usage information and message_queue_property/2 to get the number of queued messages for a thread.

thread_statistics(+Id, +Key, -Value)
  Obtains statistical information on thread Id as statistics/2 does in single-threaded applications. This call supports all keys of statistics/2, although only stack sizes, `cputime`, `inferences`, `epoch`, `errors` and `warnings` yield different values for each thread. For `errors` and `warnings` statistics/2 gives the global process count and this predicate gives the counts for the calling thread.198There is no portable interface to obtain thread-specific CPU time and some operating systems provide no access to this information at all. On such systems the total process CPU is returned. Thread CPU time is supported on MS-Windows, Linux and MacOSX.
mutex_statistics
  Print usage statistics on internal mutexes and mutexes associated with dynamic predicates. For each mutex two numbers are printed: the number of times the mutex was acquired and the number of collisions: the number of times the calling thread has to wait for the mutex. The output is written to `current_output` and can thus be redirected using with_output_to/2.