Several thread libraries exist for C. Among them, the Pthreads
library  implements the POSIX standard for
preemptive threads. LinuxThreads  is an
implementation of Pthreads for Linux; it is based on kernel-level threads.
Quick Threads  provides programmers with
a minimal support for multithreading at user-space level. Basically,
it implements context-switching in assembly code, and is thus a
low-level solution to multithreading.
Gnu Portable Threads  (GNU Pth) is a library of purely
cooperative threads which has portability as main objective. The Next
Generation POSIX Threading project  proposes to extend
GNU Pth to the M:N model, with Linux SMP machines as target.
Java introduce threads at language level. Actually, threads are
generally heavily used in Java, for example when graphics or
networking is involved. No assumption is made on the way threads are
scheduled (cooperative or preemptive scheduling) wich makes Java
multithreaded systems difficult to program and to port . This difficulty is pointed out by the suppression from the
recent versions of the language of the threads primitives to gain fine
control over threads . A first version of
FairThreads has been proposed in the context of the Java language  in order to simplify concurrent programming in Java.
Threads in Functional Languages
Threads are used in several ML-based languages such as CML . CML is preemptively scheduled and threads communication is
synchronous and based on channels. Threads are also introduced in
CAML ; they are implemented by time-sharing
on a single processor, and thus cannot benefit from multiprocessors
FairThreads has been recently introduced in the Bigloo 
implementation of Scheme. The present version only supports linked
threads, and special constructs are introduced to deal with
FairThreads actually comes out from the so-called reactive approach . In this approach, one basically has instants and
broadcast events. As opposite to synchronous languages  such as Esterel, the absence of an event during one
instant cannot be decided before the end of this very instant. As a
consequence, the reaction to the absence of one event is delayed to
the next instant. This is a way to solve so-called "causality
problems" which are raised with synchronous languages, and which are
obstacles to modularity. The Reactive-C 
language was the first proposal for reactive programming in C;
in this respect, FairThreads can be considered as a descendant of it.
Chores  and filaments  are small pieces of code that do not have private stack
and are never preempted. Chores and filaments are designed for
fine-grain parallelism programming on shared-memory machines. Chores
and filaments are completely executed and cannot be suspended nor
resumed. Generally, a pool of threads is devoted to execute them.
Chores and chunk-based techniques are described in details in the
context of the Java language in  and . Automata in FairThreads are close to chores and filaments,
but give programmers more freedom for direct coding of states-based
algorithms. Automata are also related to mode automata  in which states capture the notion of a running
mode in the context of the synchronous language Lustre.