s/task/thread/g

A part of #20038

5 files changed, 96 insertions, 96 deletions

diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index c590c0f575e..292f3e056dd 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -18,7 +18,7 @@
 //! See the `distributions` submodule for sampling random numbers from
 //! distributions like normal and exponential.
 //!
-//! # Task-local RNG
+//! # Thread-local RNG
 //!
 //! There is built-in support for a RNG associated with each task stored
 //! in task-local storage. This RNG can be accessed via `task_rng`, or
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index d64336569c6..e877dd5c6aa 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -53,7 +53,7 @@ pub mod args;
 mod at_exit_imp;
 mod libunwind;
 
-/// The default error code of the rust runtime if the main task panics instead
+/// The default error code of the rust runtime if the main thread panics instead
 /// of exiting cleanly.
 pub const DEFAULT_ERROR_CODE: int = 101;
 
@@ -137,9 +137,9 @@ fn lang_start(main: *const u8, argc: int, argv: *const *const u8) -> int {
 ///
 /// The procedure passed to this function will be executed as part of the
 /// runtime cleanup phase. For normal rust programs, this means that it will run
-/// after all other tasks have exited.
+/// after all other threads have exited.
 ///
-/// The procedure is *not* executed with a local `Task` available to it, so
+/// The procedure is *not* executed with a local `Thread` available to it, so
 /// primitives like logging, I/O, channels, spawning, etc, are *not* available.
 /// This is meant for "bare bones" usage to clean up runtime details, this is
 /// not meant as a general-purpose "let's clean everything up" function.
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index 98940a2b381..773322e4f57 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -36,7 +36,7 @@ use sys_common::stack;
 use rt::unwind;
 use rt::unwind::Unwinder;
 
-/// State associated with Rust tasks.
+/// State associated with Rust threads
 ///
 /// This structure is currently undergoing major changes, and is
 /// likely to be move/be merged with a `Thread` structure.
@@ -50,14 +50,14 @@ pub struct Task {
     awoken: bool,            // used to prevent spurious wakeups
 
     // This field holds the known bounds of the stack in (lo, hi) form. Not all
-    // native tasks necessarily know their precise bounds, hence this is
+    // native threads necessarily know their precise bounds, hence this is
     // optional.
     stack_bounds: (uint, uint),
 
     stack_guard: uint
 }
 
-// Once a task has entered the `Armed` state it must be destroyed via `drop`,
+// Once a thread has entered the `Armed` state it must be destroyed via `drop`,
 // and no other method. This state is used to track this transition.
 #[deriving(PartialEq)]
 enum TaskState {
@@ -67,31 +67,31 @@ enum TaskState {
 }
 
 pub struct TaskOpts {
-    /// Invoke this procedure with the result of the task when it finishes.
+    /// Invoke this procedure with the result of the thread when it finishes.
     pub on_exit: Option<Thunk<Result>>,
-    /// A name for the task-to-be, for identification in panic messages
+    /// A name for the thread-to-be, for identification in panic messages
     pub name: Option<SendStr>,
-    /// The size of the stack for the spawned task
+    /// The size of the stack for the spawned thread
     pub stack_size: Option<uint>,
 }
 
-/// Indicates the manner in which a task exited.
+/// Indicates the manner in which a thread exited.
 ///
-/// A task that completes without panicking is considered to exit successfully.
+/// A thread that completes without panicking is considered to exit successfully.
 ///
 /// If you wish for this result's delivery to block until all
-/// children tasks complete, recommend using a result future.
+/// children threads complete, recommend using a result future.
 pub type Result = ::core::result::Result<(), Box<Any + Send>>;
 
-/// A handle to a blocked task. Usually this means having the Box<Task>
-/// pointer by ownership, but if the task is killable, a killer can steal it
+/// A handle to a blocked thread. Usually this means having the Box<Task>
+/// pointer by ownership, but if the thread is killable, a killer can steal it
 /// at any time.
 pub enum BlockedTask {
     Owned(Box<Task>),
     Shared(Arc<AtomicUint>),
 }
 
-/// Per-task state related to task death, killing, panic, etc.
+/// Per-thread state related to thread death, killing, panic, etc.
 pub struct Death {
     pub on_exit: Option<Thunk<Result>>,
 }
@@ -101,7 +101,7 @@ pub struct BlockedTasks {
 }
 
 impl Task {
-    /// Creates a new uninitialized task.
+    /// Creates a new uninitialized thread.
     pub fn new(stack_bounds: Option<(uint, uint)>, stack_guard: Option<uint>) -> Task {
         Task {
             unwinder: Unwinder::new(),
@@ -153,17 +153,17 @@ impl Task {
         })
     }
 
-    /// Consumes ownership of a task, runs some code, and returns the task back.
+    /// Consumes ownership of a thread, runs some code, and returns the thread back.
     ///
     /// This function can be used as an emulated "try/catch" to interoperate
     /// with the rust runtime at the outermost boundary. It is not possible to
     /// use this function in a nested fashion (a try/catch inside of another
     /// try/catch). Invoking this function is quite cheap.
     ///
-    /// If the closure `f` succeeds, then the returned task can be used again
+    /// If the closure `f` succeeds, then the returned thread can be used again
     /// for another invocation of `run`. If the closure `f` panics then `self`
     /// will be internally destroyed along with all of the other associated
-    /// resources of this task. The `on_exit` callback is invoked with the
+    /// resources of this thread. The `on_exit` callback is invoked with the
     /// cause of panic (not returned here). This can be discovered by querying
     /// `is_destroyed()`.
     ///
@@ -172,30 +172,30 @@ impl Task {
     /// guaranteed to return if it panicks. Care should be taken to ensure that
     /// stack references made by `f` are handled appropriately.
     ///
-    /// It is invalid to call this function with a task that has been previously
+    /// It is invalid to call this function with a thread that has been previously
     /// destroyed via a failed call to `run`.
     pub fn run(mut self: Box<Task>, f: ||) -> Box<Task> {
-        assert!(!self.is_destroyed(), "cannot re-use a destroyed task");
+        assert!(!self.is_destroyed(), "cannot re-use a destroyed thread");
 
         // First, make sure that no one else is in TLS. This does not allow
         // recursive invocations of run(). If there's no one else, then
         // relinquish ownership of ourselves back into TLS.
         if Local::exists(None::<Task>) {
-            panic!("cannot run a task recursively inside another");
+            panic!("cannot run a thread recursively inside another");
         }
         self.state = Armed;
         Local::put(self);
 
         // There are two primary reasons that general try/catch is unsafe. The
         // first is that we do not support nested try/catch. The above check for
-        // an existing task in TLS is sufficient for this invariant to be
+        // an existing thread in TLS is sufficient for this invariant to be
         // upheld. The second is that unwinding while unwinding is not defined.
-        // We take care of that by having an 'unwinding' flag in the task
+        // We take care of that by having an 'unwinding' flag in the thread
         // itself. For these reasons, this unsafety should be ok.
         let result = unsafe { unwind::try(f) };
 
-        // After running the closure given return the task back out if it ran
-        // successfully, or clean up the task if it panicked.
+        // After running the closure given return the thread back out if it ran
+        // successfully, or clean up the thread if it panicked.
         let task: Box<Task> = Local::take();
         match result {
             Ok(()) => task,
@@ -203,13 +203,13 @@ impl Task {
         }
     }
 
-    /// Destroy all associated resources of this task.
+    /// Destroy all associated resources of this thread.
     ///
-    /// This function will perform any necessary clean up to prepare the task
+    /// This function will perform any necessary clean up to prepare the thread
     /// for destruction. It is required that this is called before a `Task`
     /// falls out of scope.
     ///
-    /// The returned task cannot be used for running any more code, but it may
+    /// The returned thread cannot be used for running any more code, but it may
     /// be used to extract the runtime as necessary.
     pub fn destroy(self: Box<Task>) -> Box<Task> {
         if self.is_destroyed() {
@@ -219,14 +219,14 @@ impl Task {
         }
     }
 
-    /// Cleans up a task, processing the result of the task as appropriate.
+    /// Cleans up a thread, processing the result of the thread as appropriate.
     ///
-    /// This function consumes ownership of the task, deallocating it once it's
+    /// This function consumes ownership of the thread, deallocating it once it's
     /// done being processed. It is assumed that TLD and the local heap have
     /// already been destroyed and/or annihilated.
     fn cleanup(mut self: Box<Task>, result: Result) -> Box<Task> {
         // After taking care of the data above, we need to transmit the result
-        // of this task.
+        // of this thread.
         let what_to_do = self.death.on_exit.take();
         Local::put(self);
 
@@ -235,15 +235,15 @@ impl Task {
         //        if this panics, this will also likely abort the runtime.
         //
         //        This closure is currently limited to a channel send via the
-        //        standard library's task interface, but this needs
+        //        standard library's thread interface, but this needs
         //        reconsideration to whether it's a reasonable thing to let a
-        //        task to do or not.
+        //        thread to do or not.
         match what_to_do {
             Some(f) => { f.invoke(result) }
             None => { drop(result) }
         }
 
-        // Now that we're done, we remove the task from TLS and flag it for
+        // Now that we're done, we remove the thread from TLS and flag it for
         // destruction.
         let mut task: Box<Task> = Local::take();
         task.state = Destroyed;
@@ -253,7 +253,7 @@ impl Task {
     /// Queries whether this can be destroyed or not.
     pub fn is_destroyed(&self) -> bool { self.state == Destroyed }
 
-    /// Deschedules the current task, invoking `f` `amt` times. It is not
+    /// Deschedules the current thread, invoking `f` `amt` times. It is not
     /// recommended to use this function directly, but rather communication
     /// primitives in `std::comm` should be used.
     //
@@ -262,31 +262,31 @@ impl Task {
     // shared state. Additionally, all of the violations are protected with a
     // mutex, so in theory there are no races.
     //
-    // The first thing we need to do is to get a pointer to the task's internal
-    // mutex. This address will not be changing (because the task is allocated
-    // on the heap). We must have this handle separately because the task will
+    // The first thing we need to do is to get a pointer to the thread's internal
+    // mutex. This address will not be changing (because the thread is allocated
+    // on the heap). We must have this handle separately because the thread will
     // have its ownership transferred to the given closure. We're guaranteed,
     // however, that this memory will remain valid because *this* is the current
-    // task's execution thread.
+    // thread's execution thread.
     //
-    // The next weird part is where ownership of the task actually goes. We
+    // The next weird part is where ownership of the thread actually goes. We
     // relinquish it to the `f` blocking function, but upon returning this
-    // function needs to replace the task back in TLS. There is no communication
-    // from the wakeup thread back to this thread about the task pointer, and
-    // there's really no need to. In order to get around this, we cast the task
+    // function needs to replace the thread back in TLS. There is no communication
+    // from the wakeup thread back to this thread about the thread pointer, and
+    // there's really no need to. In order to get around this, we cast the thread
     // to a `uint` which is then used at the end of this function to cast back
     // to a `Box<Task>` object. Naturally, this looks like it violates
     // ownership semantics in that there may be two `Box<Task>` objects.
     //
     // The fun part is that the wakeup half of this implementation knows to
-    // "forget" the task on the other end. This means that the awakening half of
+    // "forget" the thread on the other end. This means that the awakening half of
     // things silently relinquishes ownership back to this thread, but not in a
-    // way that the compiler can understand. The task's memory is always valid
-    // for both tasks because these operations are all done inside of a mutex.
+    // way that the compiler can understand. The thread's memory is always valid
+    // for both threads because these operations are all done inside of a mutex.
     //
     // You'll also find that if blocking fails (the `f` function hands the
     // BlockedTask back to us), we will `mem::forget` the handles. The
-    // reasoning for this is the same logic as above in that the task silently
+    // reasoning for this is the same logic as above in that the thread silently
     // transfers ownership via the `uint`, not through normal compiler
     // semantics.
     //
@@ -319,11 +319,11 @@ impl Task {
                 let guard = (*me).lock.lock();
                 (*me).awoken = false;
 
-                // Apply the given closure to all of the "selectable tasks",
+                // Apply the given closure to all of the "selectable threads",
                 // bailing on the first one that produces an error. Note that
                 // care must be taken such that when an error is occurred, we
-                // may not own the task, so we may still have to wait for the
-                // task to become available. In other words, if task.wake()
+                // may not own the thread, so we may still have to wait for the
+                // thread to become available. In other words, if thread.wake()
                 // returns `None`, then someone else has ownership and we must
                 // wait for their signal.
                 match iter.map(f).filter_map(|a| a.err()).next() {
@@ -342,15 +342,15 @@ impl Task {
                     guard.wait();
                 }
             }
-            // put the task back in TLS, and everything is as it once was.
+            // put the thread back in TLS, and everything is as it once was.
             Local::put(mem::transmute(me));
         }
     }
 
-    /// Wakes up a previously blocked task. This function can only be
-    /// called on tasks that were previously blocked in `deschedule`.
+    /// Wakes up a previously blocked thread. This function can only be
+    /// called on threads that were previously blocked in `deschedule`.
     //
-    // See the comments on `deschedule` for why the task is forgotten here, and
+    // See the comments on `deschedule` for why the thread is forgotten here, and
     // why it's valid to do so.
     pub fn reawaken(mut self: Box<Task>) {
         unsafe {
@@ -362,21 +362,21 @@ impl Task {
         }
     }
 
-    /// Yields control of this task to another task. This function will
+    /// Yields control of this thread to another thread. This function will
     /// eventually return, but possibly not immediately. This is used as an
-    /// opportunity to allow other tasks a chance to run.
+    /// opportunity to allow other threads a chance to run.
     pub fn yield_now() {
         Thread::yield_now();
     }
 
-    /// Returns the stack bounds for this task in (lo, hi) format. The stack
-    /// bounds may not be known for all tasks, so the return value may be
+    /// Returns the stack bounds for this thread in (lo, hi) format. The stack
+    /// bounds may not be known for all threads, so the return value may be
     /// `None`.
     pub fn stack_bounds(&self) -> (uint, uint) {
         self.stack_bounds
     }
 
-    /// Returns the stack guard for this task, if known.
+    /// Returns the stack guard for this thread, if known.
     pub fn stack_guard(&self) -> Option<uint> {
         if self.stack_guard != 0 {
             Some(self.stack_guard)
@@ -385,9 +385,9 @@ impl Task {
         }
     }
 
-    /// Consume this task, flagging it as a candidate for destruction.
+    /// Consume this thread, flagging it as a candidate for destruction.
     ///
-    /// This function is required to be invoked to destroy a task. A task
+    /// This function is required to be invoked to destroy a thread. A thread
     /// destroyed through a normal drop will abort.
     pub fn drop(mut self) {
         self.state = Destroyed;
@@ -396,7 +396,7 @@ impl Task {
 
 impl Drop for Task {
     fn drop(&mut self) {
-        rtdebug!("called drop for a task: {}", self as *mut Task as uint);
+        rtdebug!("called drop for a thread: {}", self as *mut Task as uint);
         rtassert!(self.state != Armed);
     }
 }
@@ -414,7 +414,7 @@ impl Iterator<BlockedTask> for BlockedTasks {
 }
 
 impl BlockedTask {
-    /// Returns Some if the task was successfully woken; None if already killed.
+    /// Returns Some if the thread was successfully woken; None if already killed.
     pub fn wake(self) -> Option<Box<Task>> {
         match self {
             Owned(task) => Some(task),
@@ -427,7 +427,7 @@ impl BlockedTask {
         }
     }
 
-    /// Reawakens this task if ownership is acquired. If finer-grained control
+    /// Reawakens this thread if ownership is acquired. If finer-grained control
     /// is desired, use `wake` instead.
     pub fn reawaken(self) {
         self.wake().map(|t| t.reawaken());
@@ -438,12 +438,12 @@ impl BlockedTask {
     #[cfg(not(test))] pub fn trash(self) { }
     #[cfg(test)]      pub fn trash(self) { assert!(self.wake().is_none()); }
 
-    /// Create a blocked task, unless the task was already killed.
+    /// Create a blocked thread, unless the thread was already killed.
     pub fn block(task: Box<Task>) -> BlockedTask {
         Owned(task)
     }
 
-    /// Converts one blocked task handle to a list of many handles to the same.
+    /// Converts one blocked thread handle to a list of many handles to the same.
     pub fn make_selectable(self, num_handles: uint) -> Take<BlockedTasks> {
         let arc = match self {
             Owned(task) => {
@@ -543,7 +543,7 @@ mod test {
         drop(Task::new(None, None));
     }
 
-    // Task blocking tests
+    // Thread blocking tests
 
     #[test]
     fn block_and_wake() {
diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs
index eb15a7ba378..4d57db9a929 100644
--- a/src/libstd/rt/unwind.rs
+++ b/src/libstd/rt/unwind.rs
@@ -79,7 +79,7 @@ struct Exception {
 
 pub type Callback = fn(msg: &(Any + Send), file: &'static str, line: uint);
 
-// Variables used for invoking callbacks when a task starts to unwind.
+// Variables used for invoking callbacks when a thread starts to unwind.
 //
 // For more information, see below.
 const MAX_CALLBACKS: uint = 16;
@@ -106,14 +106,14 @@ thread_local! { static PANICKING: Cell<bool> = Cell::new(false) }
 ///
 /// * This is not safe to call in a nested fashion. The unwinding
 ///   interface for Rust is designed to have at most one try/catch block per
-///   task, not multiple. No runtime checking is currently performed to uphold
+///   thread, not multiple. No runtime checking is currently performed to uphold
 ///   this invariant, so this function is not safe. A nested try/catch block
 ///   may result in corruption of the outer try/catch block's state, especially
-///   if this is used within a task itself.
+///   if this is used within a thread itself.
 ///
-/// * It is not sound to trigger unwinding while already unwinding. Rust tasks
+/// * It is not sound to trigger unwinding while already unwinding. Rust threads
 ///   have runtime checks in place to ensure this invariant, but it is not
-///   guaranteed that a rust task is in place when invoking this function.
+///   guaranteed that a rust thread is in place when invoking this function.
 ///   Unwinding twice can lead to resource leaks where some destructors are not
 ///   run.
 pub unsafe fn try<F: FnOnce()>(f: F) -> Result<(), Box<Any + Send>> {
@@ -203,7 +203,7 @@ fn rust_exception_class() -> uw::_Unwind_Exception_Class {
 // _URC_INSTALL_CONTEXT (i.e. "invoke cleanup code") in cleanup phase.
 //
 // This is pretty close to Rust's exception handling approach, except that Rust
-// does have a single "catch-all" handler at the bottom of each task's stack.
+// does have a single "catch-all" handler at the bottom of each thread's stack.
 // So we have two versions of the personality routine:
 // - rust_eh_personality, used by all cleanup landing pads, which never catches,
 //   so the behavior of __gcc_personality_v0 is perfectly adequate there, and
@@ -523,7 +523,7 @@ pub fn begin_unwind<M: Any + Send>(msg: M, file_line: &(&'static str, uint)) ->
     // Currently this means that panic!() on OOM will invoke this code path,
     // but then again we're not really ready for panic on OOM anyway. If
     // we do start doing this, then we should propagate this allocation to
-    // be performed in the parent of this task instead of the task that's
+    // be performed in the parent of this thread instead of the thread that's
     // panicking.
 
     // see below for why we do the `Any` coercion here.
@@ -546,7 +546,7 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) ->
     static INIT: Once = ONCE_INIT;
     INIT.doit(|| unsafe { register(failure::on_fail); });
 
-    // First, invoke call the user-defined callbacks triggered on task panic.
+    // First, invoke call the user-defined callbacks triggered on thread panic.
     //
     // By the time that we see a callback has been registered (by reading
     // MAX_CALLBACKS), the actual callback itself may have not been stored yet,
@@ -574,7 +574,7 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) ->
         // If a thread panics while it's already unwinding then we
         // have limited options. Currently our preference is to
         // just abort. In the future we may consider resuming
-        // unwinding or otherwise exiting the task cleanly.
+        // unwinding or otherwise exiting the thread cleanly.
         rterrln!("thread panicked while panicking. aborting.");
         unsafe { intrinsics::abort() }
     }
@@ -582,10 +582,10 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) ->
     rust_panic(msg);
 }
 
-/// Register a callback to be invoked when a task unwinds.
+/// Register a callback to be invoked when a thread unwinds.
 ///
 /// This is an unsafe and experimental API which allows for an arbitrary
-/// callback to be invoked when a task panics. This callback is invoked on both
+/// callback to be invoked when a thread panics. This callback is invoked on both
 /// the initial unwinding and a double unwinding if one occurs. Additionally,
 /// the local `Task` will be in place for the duration of the callback, and
 /// the callback must ensure that it remains in place once the callback returns.
diff --git a/src/libstd/sync/task_pool.rs b/src/libstd/sync/task_pool.rs
index 366e4b7d35b..5fc02e7b316 100644
--- a/src/libstd/sync/task_pool.rs
+++ b/src/libstd/sync/task_pool.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Abstraction of a task pool for basic parallelism.
+//! Abstraction of a thread pool for basic parallelism.
 
 use core::prelude::*;
 
@@ -45,9 +45,9 @@ impl<'a> Drop for Sentinel<'a> {
     }
 }
 
-/// A task pool used to execute functions in parallel.
+/// A thread pool used to execute functions in parallel.
 ///
-/// Spawns `n` worker tasks and replenishes the pool if any worker tasks
+/// Spawns `n` worker threads and replenishes the pool if any worker threads
 /// panic.
 ///
 /// # Example
@@ -69,34 +69,34 @@ impl<'a> Drop for Sentinel<'a> {
 /// assert_eq!(rx.iter().take(8u).sum(), 8u);
 /// ```
 pub struct TaskPool {
-    // How the taskpool communicates with subtasks.
+    // How the threadpool communicates with subthreads.
     //
-    // This is the only such Sender, so when it is dropped all subtasks will
+    // This is the only such Sender, so when it is dropped all subthreads will
     // quit.
     jobs: Sender<Thunk>
 }
 
 impl TaskPool {
-    /// Spawns a new task pool with `tasks` tasks.
+    /// Spawns a new thread pool with `threads` threads.
     ///
     /// # Panics
     ///
-    /// This function will panic if `tasks` is 0.
-    pub fn new(tasks: uint) -> TaskPool {
-        assert!(tasks >= 1);
+    /// This function will panic if `threads` is 0.
+    pub fn new(threads: uint) -> TaskPool {
+        assert!(threads >= 1);
 
         let (tx, rx) = channel::<Thunk>();
         let rx = Arc::new(Mutex::new(rx));
 
-        // Taskpool tasks.
-        for _ in range(0, tasks) {
+        // Threadpool threads
+        for _ in range(0, threads) {
             spawn_in_pool(rx.clone());
         }
 
         TaskPool { jobs: tx }
     }
 
-    /// Executes the function `job` on a task in the pool.
+    /// Executes the function `job` on a thread in the pool.
     pub fn execute<F>(&self, job: F)
         where F : FnOnce(), F : Send
     {
@@ -106,7 +106,7 @@ impl TaskPool {
 
 fn spawn_in_pool(jobs: Arc<Mutex<Receiver<Thunk>>>) {
     Thread::spawn(move |:| {
-        // Will spawn a new task on panic unless it is cancelled.
+        // Will spawn a new thread on panic unless it is cancelled.
         let sentinel = Sentinel::new(&jobs);
 
         loop {
@@ -165,12 +165,12 @@ mod test {
 
         let pool = TaskPool::new(TEST_TASKS);
 
-        // Panic all the existing tasks.
+        // Panic all the existing threads.
         for _ in range(0, TEST_TASKS) {
             pool.execute(move|| -> () { panic!() });
         }
 
-        // Ensure new tasks were spawned to compensate.
+        // Ensure new threads were spawned to compensate.
         let (tx, rx) = channel();
         for _ in range(0, TEST_TASKS) {
             let tx = tx.clone();
@@ -189,7 +189,7 @@ mod test {
         let pool = TaskPool::new(TEST_TASKS);
         let waiter = Arc::new(Barrier::new(TEST_TASKS + 1));
 
-        // Panic all the existing tasks in a bit.
+        // Panic all the existing threads in a bit.
         for _ in range(0, TEST_TASKS) {
             let waiter = waiter.clone();
             pool.execute(move|| {