[Autogenerated] before we end this module,
let's mention a few other aspects of threads.
So one thing that we've seen is that threat,
the object, our dispatcher objects, their weight able objects,
you can call,
wait for single object of them as we've done in the prime example and
the threat becomes signaled when it's terminated.
And then we use that to great effect in the primes code Now,
by the way, the Colonel also has a thread pool.
In fact,
a bunch of thread pools that are available for kernel code or
device drivers running within the kernel.
The main API to use is called work item and it is fully documented and
threats themselves can wait on other dispatcher objects.
In the thread pool example of seeing a thread waiting on an event object,
which is one of those dispatcher object.
Other wearable objects are uh seMA four's for example,
jobs are also wait a ble objects.
And so threats in general can wait using the weight for single
object function or the wait for multiple objects function when you
have multiple objects that you need to wait on until all of them
become signal or just one of them.
There are also extended versions which will not be discussed in
this course on the kernel side of things.
Device drivers and kernel components can use the equivalent functions
can wait for single object from multiple objects.
The main difference is that these functions work with Colonel
objects themselves that rather than handles and that's because these
are the underlying functions that eventually the user mode functions
get to once there go over all the steps of performing the system
calls behind the scenes.