Control.Concurrent.Thread.Group

This module extends Control.Concurrent.Thread with the ability to wait for a group of threads to terminate.

This module exports equivalently named functions from Control.Concurrent, (GHC.Conc), and Control.Concurrent.Thread. Avoid ambiguities by importing this module qualified. May we suggest:

 import Control.Concurrent.Thread.Group ( ThreadGroup )
 import qualified Control.Concurrent.Thread.Group as ThreadGroup ( ... )

Documentation

data ThreadGroup

A ThreadGroup can be understood as a counter which counts the number of threads that were added to the group minus the ones that have terminated.

More formally a ThreadGroup has the following semantics:

• new initializes the counter to 0.
• Forking a thread increments the counter.
• When a forked thread terminates, whether normally or by raising an exception, the counter is decremented.
• nrOfRunning yields a transaction that returns the counter.
• wait blocks as long as the counter is greater than 0.
• waitN blocks as long as the counter is greater or equal to the specified number.

Instances

Eq ThreadGroup

Typeable ThreadGroup

new :: IO ThreadGroup

Create an empty group of threads.

nrOfRunning :: ThreadGroup -> STM Int

Yield a transaction that returns the number of running threads in the group.

Note that because this function yields a STM computation, the returned number is guaranteed to be consistent inside the transaction.

wait :: ThreadGroup -> IO ()

Convenience function which blocks until all threads, that were added to the group have terminated.

Note that: wait = waitN 1.

waitN :: Int -> ThreadGroup -> IO ()

Convenience function to help place an upper bound on the number of threads in the group.

Blocks until there are fewer threads occupied than the specified number.

Forking threads

forkIO :: ThreadGroup -> IO α -> IO (ThreadId, IO (Result α))

Same as Control.Concurrent.Thread.forkIO but additionaly adds the thread to the group.

forkOS :: ThreadGroup -> IO α -> IO (ThreadId, IO (Result α))

Same as Control.Concurrent.Thread.forkOS but additionaly adds the thread to the group.

forkOn :: Int -> ThreadGroup -> IO α -> IO (ThreadId, IO (Result α))

Same as Control.Concurrent.Thread.forkOn but additionaly adds the thread to the group.

forkIOWithUnmask :: ThreadGroup -> ((forall β. IO β -> IO β) -> IO α) -> IO (ThreadId, IO (Result α))

Same as Control.Concurrent.Thread.forkIOWithUnmask but additionaly adds the thread to the group.

forkOnWithUnmask :: Int -> ThreadGroup -> ((forall β. IO β -> IO β) -> IO α) -> IO (ThreadId, IO (Result α))

Like Control.Concurrent.Thread.forkOnWithUnmask but additionaly adds the thread to the group.